Changeset 88 for trunk/IPs/systemC/processor/Morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Makefile.deps

-              r81
+              r88
 ifndef Behavioural
 include                         $(DIR_MORPHEO)/Behavioural/Makefile.deps
+endif
+ifndef Execute_loop_Glue
+include                         $(DIR_MORPHEO)/Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/Makefile.deps
 endif
 ifndef Read_unit
 …
 Execute_loop_LIBRARY            =       -lExecute_loop                          \
                                         $(Behavioural_LIBRARY)                  \
+                                        $(Execute_loop_Glue_LIBRARY)            \
                                         $(Read_unit_LIBRARY)                    \
                                         $(Functionnal_unit_LIBRARY)             \
 …
 Execute_loop_DIR_LIBRARY        =       -L$(Execute_loop_DIR)/lib                       \
                                         $(Behavioural_DIR_LIBRARY)                      \
                                         $(Behavioural_DIR_LIBRARY)                      \
+                                        $(Execute_loop_Glue_DIR_LIBRARY)                \
                                         $(Read_unit_DIR_LIBRARY)                        \
                                         $(Functionnal_unit_DIR_LIBRARY)                 \
 …
                                 @\
                                 $(MAKE) Behavioural_library;                    \
+                                $(MAKE) Execute_loop_Glue_library;              \
                                 $(MAKE) Read_unit_library;                      \
                                 $(MAKE) Functionnal_unit_library;               \
 …
                                 @\
                                 $(MAKE) Behavioural_library_clean;                      \
+                                $(MAKE) Execute_loop_Glue_library_clean;                \
                                 $(MAKE) Read_unit_library_clean;                        \
                                 $(MAKE) Functionnal_unit_library_clean;                 \

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/src/Operation.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/include/Operation.h"
+#define neg(data)                  (~(data)+1)
+#define sign(data)                 ((data)>>(param->_size_data-1))
+#define unsigned(data)             (data)
+#define signed(data)               ((sign(data)==0)?(data):neg(data))
+#define ovf(op1, op2, res)         ((sign(op1) == sign(op2))?(sign(op1) xor sign(res)):0)
+#define carry(op1, op2, res)       (((res)<(op1)) or ((res)<(op2)))
+#define set_flag(data,flag,is_set) (((is_set)==1)?((data)|(flag)):((data)&~(flag)))
+#define get_flag(data,flag)        (((data)&(flag))!=0)
+#define concatenation_bool(a,b)    (((a)<<1) | (b))
+#include "Behavioural/include/Operation.h"
 namespace morpheo                    {
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_add");
     Tgeneral_data_t gpr1      = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2      = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1      = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2      = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3      = param->_mask_data & (gpr1 + gpr2);
     bool            overflow  = ovf  (gpr1,gpr2,gpr3);
     bool            carry_out = carry(gpr1,gpr2,gpr3);
+    bool            overflow  = ovf  (param->_size_data,gpr1,gpr2,gpr3);
+    bool            carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
     // Result
 …
     Tgeneral_data_t carry_in   = get_flag(op->_data_rc,FLAG_CY);
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = param->_mask_data & (gpr1 + gpr2 + carry_in);
     bool            overflow   = ovf  (gpr1,gpr2,gpr3);
     bool            carry_out  = carry(gpr1,gpr2,gpr3);
+    bool            overflow   = ovf  (param->_size_data,gpr1,gpr2,gpr3);
+    bool            carry_out  = carry(param->_size_data,gpr1,gpr2,gpr3);
     // Result
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sub");
     Tgeneral_data_t gpr1      =     unsigned(op->_data_ra);
     Tgeneral_data_t gpr2      = neg(unsigned(op->_data_rb));
+    Tgeneral_data_t gpr1      =                       unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2      = neg(param->_size_data,unsigned(param->_size_data,op->_data_rb));
     Tgeneral_data_t gpr3      = param->_mask_data & (gpr1 + gpr2);
     bool            overflow  = ovf  (gpr1,gpr2,gpr3);
     bool            carry_out = carry(gpr1,gpr2,gpr3);
+    bool            overflow  = ovf  (param->_size_data,gpr1,gpr2,gpr3);
+    bool            carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
     // Result
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_and");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = (gpr1 & gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_or");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = (gpr1 | gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_xor");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = (gpr1 ^ gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_movhi");
     Tgeneral_data_t gpr1       = unsigned(op->_immediat);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_immediat);
     Tgeneral_data_t gpr2       = param->_mask_data & (gpr1<<16);
 …
     Tgeneral_data_t f_in       = get_flag(op->_data_rc,FLAG_F);
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned(op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,op->_data_rb);
     Tgeneral_data_t gpr3       = ((f_in==0)?gpr2:gpr1);
 …
     Tgeneral_data_t f_in       = get_flag(op->_data_rc,FLAG_F);
     Tgeneral_data_t imm        = unsigned(op->_immediat);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
     // Result
 …
     Tgeneral_data_t f_in       = get_flag(op->_data_rc,FLAG_F);
     Tgeneral_data_t imm        = unsigned(op->_immediat);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
     // Result
 …
     Tgeneral_data_t gpr        = unsigned(op->_data_rb);
     Tgeneral_data_t imm        = unsigned(op->_immediat);
+    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_rb);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
     // Result
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_s");
     Tgeneral_data_t imm        = unsigned(op->_immediat);
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
     Tgeneral_data_t gpr2       = extend<Tgeneral_data_t>(param->_size_data, gpr1, true , imm);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_extend_z");
     Tgeneral_data_t imm        = unsigned(op->_immediat);
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
     Tgeneral_data_t gpr2       = extend<Tgeneral_data_t>(param->_size_data, gpr1, false , imm);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sll");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = param->_mask_shift & unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = shift_logic_left<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_srl");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = param->_mask_shift & unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = shift_logic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sra");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = param->_mask_shift & unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = shift_arithmetic_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ror");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = param->_mask_shift & unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = param->_mask_shift & unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     Tgeneral_data_t gpr3       = rotate_right<Tgeneral_data_t>(param->_size_data, gpr1, gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_ff1");
     Tgeneral_data_t gpr        = unsigned(op->_data_ra);
+    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_ra);
     Tgeneral_data_t index;
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_fl1");
     Tgeneral_data_t gpr        = unsigned(op->_data_ra);
+    Tgeneral_data_t gpr        = unsigned(param->_size_data,op->_data_ra);
     Tgeneral_data_t index;
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfeq");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     bool            f_out      = (gpr1 == gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfne");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     bool            f_out      = (gpr1 != gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgeu");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     bool            f_out      = (gpr1 >= gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfgtu");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     bool            f_out      = (gpr1 >  gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfleu");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     bool            f_out      = (gpr1 <= gpr2);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_sfltu");
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     bool            f_out      = (gpr1 <  gpr2);
 …
     Tgeneral_data_t gpr2       =   (op->_has_immediat==1)?op->_immediat:op->_data_rb;
     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ra  : %.8x",unsigned(op->_data_ra));
     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ras : %.8x",  signed(op->_data_ra));
     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rb  : %.8x",unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb));
     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rbs : %.8x",  signed((op->_has_immediat==1)?op->_immediat:op->_data_rb));
+    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ra  : %.8x",unsigned(param->_size_data,op->_data_ra));
+    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ras : %.8x",  signed(param->_size_data,op->_data_ra));
+    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rb  : %.8x",unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
+    log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rbs : %.8x",  signed(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
     bool            f_out;
     switch (concatenation_bool(sign(gpr1),sign(gpr2)))
+    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
+      {
       case 1 /*b01*/ : f_out = 1                               ; break;
       case 2 /*b10*/ : f_out = 0                               ; break;
       default        : f_out = signed(gpr1) >= signed(gpr2); break;
+      default        : f_out = signed(param->_size_data,gpr1) >= signed(param->_size_data,gpr2); break;
+      }
 …
     bool            f_out;
     switch (concatenation_bool(sign(gpr1),sign(gpr2)))
+    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
+      {
       case 1 /*b01*/ : f_out = 1; break;
       case 2 /*b10*/ : f_out = 0; break;
       default        : f_out = signed(gpr1) >  signed(gpr2); break;
+      default        : f_out = signed(param->_size_data,gpr1) >  signed(param->_size_data,gpr2); break;
+      }
 …
     bool            f_out;
     switch (concatenation_bool(sign(gpr1),sign(gpr2)))
+    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
+      {
       case 1 /*b01*/ : f_out = 0; break;
       case 2 /*b10*/ : f_out = 1; break;
       default        : f_out = signed(gpr1) <= signed(gpr2); break;
+      default        : f_out = signed(param->_size_data,gpr1) <= signed(param->_size_data,gpr2); break;
+      }
 …
     bool            f_out;
     switch (concatenation_bool(sign(gpr1),sign(gpr2)))
+    switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
+      {
       case 1 /*b01*/ : f_out = 0; break;
       case 2 /*b10*/ : f_out = 1; break;
       default        : f_out = signed(gpr1) <  signed(gpr2); break;
+      default        : f_out = signed(param->_size_data,gpr1) <  signed(param->_size_data,gpr2); break;
+      }
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mtspr");
     Tgeneral_data_t imm        = unsigned(op->_immediat);
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2       = unsigned(op->_data_rb);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2       = unsigned(param->_size_data,op->_data_rb);
     Tgeneral_data_t addr       = range<Tgeneral_data_t>(gpr1|imm,16);
 …
     else
+      {
         exception = EXCEPTION_ALU_SPR_ACCESS_NOT_COMPLETE;
+        exception = EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE;
+      }
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mfspr");
     Tgeneral_data_t imm        = unsigned(op->_immediat);
     Tgeneral_data_t gpr1       = unsigned(op->_data_ra);
+    Tgeneral_data_t imm        = unsigned(param->_size_data,op->_immediat);
+    Tgeneral_data_t gpr1       = unsigned(param->_size_data,op->_data_ra);
     Tgeneral_data_t gpr2       = 0;
     Tgeneral_data_t addr       = range<Tgeneral_data_t>(gpr1|imm,16);
 …
     else
+      {
         exception = EXCEPTION_ALU_SPR_ACCESS_NOT_COMPLETE;
+        exception = EXCEPTION_ALU_SPR_ACCESS_MUST_READ;
+      }
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mac");
     Tgeneral_data_t gpr1 = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2 = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     uint64_t        temp = range<uint64_t>(gpr1 * gpr2, 32);
 …
     log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_msb");
     Tgeneral_data_t gpr1 = unsigned(op->_data_ra);
     Tgeneral_data_t gpr2 = unsigned((op->_has_immediat==1)?op->_immediat:op->_data_rb);
+    Tgeneral_data_t gpr1 = unsigned(param->_size_data,op->_data_ra);
+    Tgeneral_data_t gpr2 = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     uint64_t        temp = range<uint64_t>(gpr1 * gpr2, 32);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Functionnal_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/SelfTest/src/main.cpp

-              r81
+              r88
          size_load_queue     ,
          timing              ,
+         &(morpheo::behavioural::custom::example_get_custom_information)
+         &(morpheo::behavioural::custom::example_get_custom_information),
+         true // is_toplevel
         );

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/SelfTest/src/test.cpp

-              r82
+              r88
   _data_rc       (data_rc      & gen_mask<Tspecial_data_t>(param->_size_special_data)),
   _write_rd      (write_rd     ),
   _num_reg_rd    (num_reg_rd   % param->_nb_special_register),
+  _num_reg_rd    (num_reg_rd   % (1<<param->_size_general_register)),
   _data_rd       (data_rd      & gen_mask<Tgeneral_data_t>(param->_size_general_data)),
   _write_re      (write_re     ),
   _num_reg_re    (num_reg_re   % param->_nb_special_register),
+  _num_reg_re    (num_reg_re   % (1<<param->_size_special_register)),
   _data_re       (data_re      & gen_mask<Tspecial_data_t>(param->_size_special_data)),
   _exception     (exception    ),
 …
 #ifdef STATISTICS
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
+  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,CYCLE_MAX);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Functionnal_unit * _Functionnal_unit = new Functionnal_unit (name.c_str(),
 …
 #endif
                                                                _param,
                                                                USE_ALL);
+                                                               _usage);
 #ifdef SYSTEMC
 …
   if (_param->_have_port_ooo_engine_id)
   (*(_Functionnal_unit-> in_EXECUTE_IN_OOO_ENGINE_ID )) ( in_EXECUTE_IN_OOO_ENGINE_ID );
   if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr)
   (*(_Functionnal_unit-> in_EXECUTE_IN_PACKET_ID     )) ( in_EXECUTE_IN_PACKET_ID     );
   (*(_Functionnal_unit-> in_EXECUTE_IN_OPERATION     )) ( in_EXECUTE_IN_OPERATION     );
 …
   if (_param->_have_port_ooo_engine_id)
   (*(_Functionnal_unit->out_EXECUTE_OUT_OOO_ENGINE_ID)) (out_EXECUTE_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr)
   (*(_Functionnal_unit->out_EXECUTE_OUT_PACKET_ID    )) (out_EXECUTE_OUT_PACKET_ID    );
 //(*(_Functionnal_unit->out_EXECUTE_OUT_OPERATION    )) (out_EXECUTE_OUT_OPERATION    );
 …
   transaction_in.push_back(execute_transaction(_param,0,0,0,301,OPERATION_TEST_L_SFLTS   ,TYPE_TEST,0,0         ,0x11111111,0xdeadbeef,0              ,0,63,0x0       ,1,15,0              ,EXCEPTION_NONE     ,0)); // + <  - (in unsigned)
   transaction_in.push_back(execute_transaction(_param,0,0,0,400,OPERATION_SPECIAL_L_MTSPR   ,TYPE_SPECIAL,1,GROUP_ICACHE<<11,   3,0xdeadbeef,0              ,0,63,0xdeadbeef,0, 0,0              ,EXCEPTION_ALU_SPR_ACCESS_NOT_COMPLETE,0,(GROUP_ICACHE<<11)|   3));
   transaction_in.push_back(execute_transaction(_param,0,0,0,401,OPERATION_SPECIAL_L_MTSPR   ,TYPE_SPECIAL,1,GROUP_ICACHE<<11,   5,0xdeadbeef,0              ,0,63,0xdeadbeef,0, 0,0              ,EXCEPTION_ALU_SPR_ACCESS_NOT_COMPLETE,0,(GROUP_ICACHE<<11)|   5));
+  transaction_in.push_back(execute_transaction(_param,0,0,0,400,OPERATION_SPECIAL_L_MTSPR   ,TYPE_SPECIAL,1,GROUP_ICACHE<<11,   3,0xdeadbeef,0              ,0,63,0xdeadbeef,0, 0,0              ,EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE  ,0,(GROUP_ICACHE<<11)|   3));
+  transaction_in.push_back(execute_transaction(_param,0,0,0,401,OPERATION_SPECIAL_L_MTSPR   ,TYPE_SPECIAL,1,GROUP_ICACHE<<11,   5,0xdeadbeef,0              ,0,63,0xdeadbeef,0, 0,0              ,EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE  ,0,(GROUP_ICACHE<<11)|   5));
   transaction_in.push_back(execute_transaction(_param,0,0,0,402,OPERATION_SPECIAL_L_MTSPR   ,TYPE_SPECIAL,1,GROUP_MAC   <<11,   0,0xdeadbeef,0              ,0,63,0xdeadbeef,0, 0,0              ,EXCEPTION_ALU_SPR_ACCESS_INVALID     ,0,(GROUP_MAC   <<11)|   0));
   transaction_in.push_back(execute_transaction(_param,0,0,0,403,OPERATION_SPECIAL_L_MTSPR   ,TYPE_SPECIAL,1,GROUP_MAC   <<11,   1,0xdeadbeef,0              ,0,63,0xdeadbeef,0, 0,0              ,EXCEPTION_ALU_NONE                   ,0,(GROUP_MAC   <<11)|   1));
 …
               if (_param->_have_port_ooo_engine_id)
               in_EXECUTE_IN_OOO_ENGINE_ID .write(transaction_in.front()._ooo_engine_id);
               if (_param->_have_port_packet_id)
+              if (_param->_have_port_rob_ptr)
               in_EXECUTE_IN_PACKET_ID     .write(transaction_in.front()._packet_id    );
               in_EXECUTE_IN_OPERATION     .write(transaction_in.front()._operation    );
 …
+            {
               // TEST
               if (_param->_have_port_packet_id)
+              if (_param->_have_port_rob_ptr)
               TEST(Tpacket_t         , out_EXECUTE_OUT_PACKET_ID    .read(), transaction_out.front()._packet_id    );
               if (_param->_have_port_context_id)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h

-              r82
+              r88
   private   : Tcontrol_t                      internal_EXECUTE_IN_ACK;
   private   : Tcontrol_t                      internal_EXECUTE_OUT_VAL;
+  private   : bool                            reg_BUSY;
+  private   : bool                            reg_BUSY_IN ;
+  private   : bool                            reg_BUSY_OUT;
+  private   : execute_operation_t           * _execute_operation;
+  private   : execute_operation_t           * _execute_operation_in ;
+  private   : execute_operation_t           * _execute_operation_out;
   private   : execute_register_t         **** _execute_register;
   private   : execute_param_t               * _execute_param;
 …
   public  : void        transition                (void);
   public  : void        genMoore                  (void);
-  public  : void        genMealy                  (void);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Parameters.h

-              r81
+              r88
 namespace functionnal_unit {
   class Parameters : public morpheo::behavioural::Parameters
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t            _nb_context                   ;
   public : const uint32_t            _nb_front_end                 ;
   public : const uint32_t            _nb_ooo_engine                ;
   public : const uint32_t            _nb_packet                    ;
   public : const uint32_t            _size_general_data            ;
   public : const uint32_t            _nb_general_register          ;
   public : const uint32_t            _size_special_data            ;
   public : const uint32_t            _nb_special_register          ;
   public : const uint32_t            _size_store_queue             ;
   public : const uint32_t            _size_load_queue              ;
+  public : uint32_t            _nb_context                   ;
+  public : uint32_t            _nb_front_end                 ;
+  public : uint32_t            _nb_ooo_engine                ;
+  public : uint32_t            _nb_packet                    ;
+//public : uint32_t            _size_general_data            ;
+//public : uint32_t            _size_special_data            ;
+//public : uint32_t            _nb_general_register          ;
+//public : uint32_t            _nb_special_register          ;
+//public : uint32_t            _size_store_queue             ;
+//public : uint32_t            _size_load_queue              ;
   public :       execute_timing_t ** _timing                       ;
   public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (uint32_t);
+  public : execute_timing_t ** _timing                       ;
+  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void);
   public : const uint32_t            _size_context_id              ;
   public : const uint32_t            _size_front_end_id            ;
   public : const uint32_t            _size_ooo_engine_id           ;
   public : const uint32_t            _size_packet_id               ;
   public : const uint32_t            _size_general_register        ;
   public : const uint32_t            _size_special_register        ;
+//public : uint32_t            _size_context_id              ;
+//public : uint32_t            _size_front_end_id            ;
+//public : uint32_t            _size_ooo_engine_id           ;
+//public : uint32_t            _size_packet_id               ;
+//public : uint32_t            _size_general_register        ;
+//public : uint32_t            _size_special_register        ;
   public : const bool                _have_port_context_id         ;
   public : const bool                _have_port_front_end_id       ;
   public : const bool                _have_port_ooo_engine_id      ;
   public : const bool                _have_port_packet_id          ;
   public : const bool                _have_port_load_queue_ptr     ;
+//public : bool                _have_port_context_id         ;
+//public : bool                _have_port_front_end_id       ;
+//public : bool                _have_port_ooo_engine_id      ;
+//public : bool                _have_port_packet_id          ;
+//public : bool                _have_port_load_queue_ptr     ;
   public : const bool                _have_groupe_MAC              ;
+  public : bool                _have_groupe_MAC              ;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t           size_load_queue    ,
                         execute_timing_t** timing             ,
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t));
+  public : Parameters  (Parameters & param) ;
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                        bool               is_toplevel=true
+                        );
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit.cpp

-              r81
+              r88
     allocation ();
+#if DEBUG_Functionnal_unit == true
+    log_printf(INFO,Functionnal_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Functionnal_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Functionnal_unit,FUNCTION,"Method - transition");
 …
 # endif
-        log_printf(INFO,Functionnal_unit,FUNCTION,"Method - genMealy");
-        SC_METHOD (genMealy);
-        dont_initialize ();
-        sensitive << (*(in_CLOCK)).neg()
-                  << (*(in_EXECUTE_OUT_ACK));
-# ifdef SYSTEMCASS_SPECIFIC
-        // List dependency information
-        (*(out_EXECUTE_IN_ACK)) (*(in_EXECUTE_OUT_ACK));
-# endif
 #endif
+      }
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Functionnal_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_allocation.cpp

-              r81
+              r88
       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_packet_id)
        in_EXECUTE_IN_PACKET_ID     = interface->set_signal_in <Tpacket_t         > ("packet_id"    , _param->_size_packet_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",log2(_param->_size_store_queue));
+       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" ,log2(_param->_size_load_queue));
+       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);
 …
        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_packet_id)
        out_EXECUTE_OUT_PACKET_ID      = interface->set_signal_out<Tpacket_t         > ("packet_id"    ,_param->_size_packet_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         );
 …
+     }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     _execute_operation = new execute_operation_t;
+     _execute_param     = new execute_param_t(_param->_size_general_data,
+                                              _param->_timing);
+     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     if (usage_is_set(_usage,USE_SYSTEMC))
+       {
+     _execute_operation_in  = new execute_operation_t;
+     _execute_operation_out = new execute_operation_t;
+     _execute_param         = new execute_param_t(_param->_size_general_data,
+                                                  _param->_timing);
      _execute_register = new execute_register_t *** [_param->_nb_context];
 …
              for (uint32_t k=0; k<_param->_nb_ooo_engine; k++)
+               {
                  uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
                                                       j,_param->_size_front_end_id,
                                                       k,_param->_size_ooo_engine_id);
+//               uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
+//                                                    j,_param->_size_front_end_id,
+//                                                    k,_param->_size_ooo_engine_id);
                  _execute_register [i][j][k] = new execute_register_t;
 …
                  for (uint32_t x=GROUP_CUSTOM_1; x<GROUP_CUSTOM_8; x++)
                    if ((_param->_get_custom_information(num_thread))._get_valid_group(x) == true)
+                   if ((_param->_get_custom_information())._get_valid_group(x) == true)
+                     {
                        uint32_t nb_reg = (_param->_get_custom_information(num_thread))._get_nb_register(x);
+                       uint32_t nb_reg = (_param->_get_custom_information())._get_nb_register(x);
                        _execute_register[i][j][k]->implement_group(x,nb_reg);
                        for (uint32_t y=0; y<nb_reg; y++)
                          _execute_register[i][j][k]->_spr_access_mode->change_mode(x,y,(_param->_get_custom_information(num_thread))._get_access_mode(x,y));
+                         _execute_register[i][j][k]->_spr_access_mode->change_mode(x,y,(_param->_get_custom_information())._get_access_mode(x,y));
+                     }
+               }
 …
      if (_param->_timing[TYPE_TEST   ][OPERATION_TEST_L_SFNE       ]._latence > 0)
        _function_execute[TYPE_TEST   ][OPERATION_TEST_L_SFNE       ] = &(operation_l_sfne    );
 //   if (_param->_timing[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_MUL     ]._latence > 0)
 //     _function_execute[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_MUL     ] = &(operation_l_mul     );
 //   if (_param->_timing[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_MULU    ]._latence > 0)
 //     _function_execute[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_MULU    ] = &(operation_l_mulu    );
 //   if (_param->_timing[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_DIV     ]._latence > 0)
 //     _function_execute[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_DIV     ] = &(operation_l_div     );
 //   if (_param->_timing[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_DIVU    ]._latence > 0)
 //     _function_execute[TYPE_MUL_DIV][OPERATION_MUL_DIV_L_DIVU    ] = &(operation_l_divu    );
+//   if (_param->_timing[TYPE_MUL    ][OPERATION_MUL_L_MUL         ]._latence > 0)
+//     _function_execute[TYPE_MUL    ][OPERATION_MUL_L_MUL         ] = &(operation_l_mul     );
+//   if (_param->_timing[TYPE_MUL    ][OPERATION_MUL_L_MULU        ]._latence > 0)
+//     _function_execute[TYPE_DIV    ][OPERATION_MUL_L_MULU        ] = &(operation_l_mulu    );
+//   if (_param->_timing[TYPE_DIV    ][OPERATION_DIV_L_DIV         ]._latence > 0)
+//     _function_execute[TYPE_DIV    ][OPERATION_DIV_L_DIV         ] = &(operation_l_div     );
+//   if (_param->_timing[TYPE_DIV    ][OPERATION_DIV_L_DIVU        ]._latence > 0)
+//     _function_execute[TYPE_DIV    ][OPERATION_DIV_L_DIVU        ] = &(operation_l_divu    );
      if (_param->_timing[TYPE_EXTEND ][OPERATION_EXTEND_L_EXTEND_S ]._latence > 0)
        _function_execute[TYPE_EXTEND ][OPERATION_EXTEND_L_EXTEND_S ] = &(operation_l_extend_s);
 …
      if (_param->_timing[TYPE_BRANCH ][OPERATION_BRANCH_L_JALR     ]._latence > 0)
        _function_execute[TYPE_BRANCH ][OPERATION_BRANCH_L_JALR     ] = &(operation_l_jalr    );
+#ifdef POSITION
     _component->generate_file();
+       }
+#ifdef POSITION
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete  in_EXECUTE_IN_OOO_ENGINE_ID ;
         if (_param->_have_port_packet_id)
+        if (_param->_have_port_rob_ptr)
         delete  in_EXECUTE_IN_PACKET_ID     ;
         delete  in_EXECUTE_IN_OPERATION     ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete out_EXECUTE_OUT_OOO_ENGINE_ID  ;
         if (_param->_have_port_packet_id)
+        if (_param->_have_port_rob_ptr)
         delete out_EXECUTE_OUT_PACKET_ID      ;
       //delete out_EXECUTE_OUT_OPERATION      ;
 …
         delete out_EXECUTE_OUT_NO_SEQUENCE    ;
         delete out_EXECUTE_OUT_ADDRESS        ;
+        // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] _execute_register;
+        delete    _execute_param;
+        delete    _execute_operation_in;
+        delete    _execute_operation_out;
+        delete [] _function_execute;
+      }
-    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] _execute_register;
-    delete    _execute_param;
-    delete    _execute_operation;
-    delete [] _function_execute;
     delete    _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_genMoore.cpp

-              r81
+              r88
   void Functionnal_unit::genMoore (void)
+  {
+    log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
+    log_begin(Functionnal_unit,FUNCTION);
+    log_function(Functionnal_unit,FUNCTION,_name.c_str());
+    internal_EXECUTE_OUT_VAL = reg_BUSY and (_execute_operation->_timing._latence == 0);
+    {
+      internal_EXECUTE_IN_ACK = not reg_BUSY_IN;
+      PORT_WRITE(out_EXECUTE_IN_ACK           , internal_EXECUTE_IN_ACK);
+    }
+    PORT_WRITE(out_EXECUTE_OUT_VAL          , internal_EXECUTE_OUT_VAL);
+    if (_param->_have_port_context_id)
+    PORT_WRITE(out_EXECUTE_OUT_CONTEXT_ID   ,_execute_operation->_context_id   );
+    if (_param->_have_port_front_end_id)
+    PORT_WRITE(out_EXECUTE_OUT_FRONT_END_ID ,_execute_operation->_front_end_id );
+    if (_param->_have_port_ooo_engine_id)
+    PORT_WRITE(out_EXECUTE_OUT_OOO_ENGINE_ID,_execute_operation->_ooo_engine_id);
+    if (_param->_have_port_packet_id)
+    PORT_WRITE(out_EXECUTE_OUT_PACKET_ID    ,_execute_operation->_packet_id    );
+  //PORT_WRITE(out_EXECUTE_OUT_OPERATION    ,_execute_operation->_operation    );
+    PORT_WRITE(out_EXECUTE_OUT_TYPE         ,_execute_operation->_type         );
+    PORT_WRITE(out_EXECUTE_OUT_WRITE_RD     ,_execute_operation->_write_rd     );
+    PORT_WRITE(out_EXECUTE_OUT_NUM_REG_RD   ,_execute_operation->_num_reg_rd   );
+    PORT_WRITE(out_EXECUTE_OUT_DATA_RD      ,_execute_operation->_data_rd      );
+    PORT_WRITE(out_EXECUTE_OUT_WRITE_RE     ,_execute_operation->_write_re     );
+    PORT_WRITE(out_EXECUTE_OUT_NUM_REG_RE   ,_execute_operation->_num_reg_re   );
+    PORT_WRITE(out_EXECUTE_OUT_DATA_RE      ,_execute_operation->_data_re      );
+    PORT_WRITE(out_EXECUTE_OUT_EXCEPTION    ,_execute_operation->_exception    );
+    PORT_WRITE(out_EXECUTE_OUT_NO_SEQUENCE  ,_execute_operation->_no_sequence  );
+    PORT_WRITE(out_EXECUTE_OUT_ADDRESS      ,_execute_operation->_address      );
+    {
+      internal_EXECUTE_OUT_VAL = reg_BUSY_OUT and (_execute_operation_out->_timing._latence == 0);
+      PORT_WRITE(out_EXECUTE_OUT_VAL          , internal_EXECUTE_OUT_VAL);
+      if (_param->_have_port_context_id)
+      PORT_WRITE(out_EXECUTE_OUT_CONTEXT_ID   ,_execute_operation_out->_context_id   );
+      if (_param->_have_port_front_end_id)
+      PORT_WRITE(out_EXECUTE_OUT_FRONT_END_ID ,_execute_operation_out->_front_end_id );
+      if (_param->_have_port_ooo_engine_id)
+      PORT_WRITE(out_EXECUTE_OUT_OOO_ENGINE_ID,_execute_operation_out->_ooo_engine_id);
+      if (_param->_have_port_rob_ptr)
+      PORT_WRITE(out_EXECUTE_OUT_PACKET_ID    ,_execute_operation_out->_packet_id    );
+  //  PORT_WRITE(out_EXECUTE_OUT_OPERATION    ,_execute_operation_out->_operation    );
+      PORT_WRITE(out_EXECUTE_OUT_TYPE         ,_execute_operation_out->_type         );
+      PORT_WRITE(out_EXECUTE_OUT_WRITE_RD     ,_execute_operation_out->_write_rd     );
+      PORT_WRITE(out_EXECUTE_OUT_NUM_REG_RD   ,_execute_operation_out->_num_reg_rd   );
+      PORT_WRITE(out_EXECUTE_OUT_DATA_RD      ,_execute_operation_out->_data_rd      );
+      PORT_WRITE(out_EXECUTE_OUT_WRITE_RE     ,_execute_operation_out->_write_re     );
+      PORT_WRITE(out_EXECUTE_OUT_NUM_REG_RE   ,_execute_operation_out->_num_reg_re   );
+      PORT_WRITE(out_EXECUTE_OUT_DATA_RE      ,_execute_operation_out->_data_re      );
+      PORT_WRITE(out_EXECUTE_OUT_EXCEPTION    ,_execute_operation_out->_exception    );
+      PORT_WRITE(out_EXECUTE_OUT_NO_SEQUENCE  ,_execute_operation_out->_no_sequence  );
+      PORT_WRITE(out_EXECUTE_OUT_ADDRESS      ,_execute_operation_out->_address      );
+    }
     log_printf(FUNC,Functionnal_unit,FUNCTION,"End");
+    log_end(Functionnal_unit,FUNCTION);
   };
 …
 }; // end namespace multi_execute_loop
 }; // end namespace core
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Functionnal_unit_transition.cpp

-              r81
+              r88
   void Functionnal_unit::transition (void)
+  {
+    log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
+    log_begin(Functionnal_unit,FUNCTION);
+    log_function(Functionnal_unit,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
+      {
+        reg_BUSY = false;
+        reg_BUSY_IN  = false;
+        reg_BUSY_OUT = false;
         for (uint32_t i=0; i<_param->_nb_context; i++)
 …
             for (uint32_t k=0; k<_param->_nb_ooo_engine; k++)
+              {
                 uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
                                                      j,_param->_size_front_end_id,
                                                      k,_param->_size_ooo_engine_id);
+//              uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
+//                                                   j,_param->_size_front_end_id,
+//                                                   k,_param->_size_ooo_engine_id);
                 for (uint32_t x=GROUP_CUSTOM_1; x<GROUP_CUSTOM_8; x++)
+                  {
                     function_execute_end_cycle_t * fct = (_param->_get_custom_information(num_thread)._get_custom_execute_reset(x));
+                    function_execute_end_cycle_t * fct = (_param->_get_custom_information()._get_custom_execute_reset(x));
                     if (fct != NULL)
 …
         if (internal_EXECUTE_OUT_VAL and PORT_READ(in_EXECUTE_OUT_ACK))
+          {
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"  * EXECUTE_OUT : Transaction Accepted");
             // transaction
             reg_BUSY = false;
+            reg_BUSY_OUT = false;
+          }
 …
         if (PORT_READ(in_EXECUTE_IN_VAL) and internal_EXECUTE_IN_ACK)
+          {
+            reg_BUSY = true;
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"  * EXECUTE_IN : Transaction Accepted");
+            reg_BUSY_IN = true;
             Tcontext_t   context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_IN_CONTEXT_ID   ):0;
             Tcontext_t   front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_IN_FRONT_END_ID ):0;
             Tcontext_t   ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_IN_OOO_ENGINE_ID):0;
             Tcontext_t   packet_id     = (_param->_have_port_packet_id    )?PORT_READ(in_EXECUTE_IN_PACKET_ID    ):0;
+            Tcontext_t   packet_id     = (_param->_have_port_rob_ptr      )?PORT_READ(in_EXECUTE_IN_PACKET_ID    ):0;
             Toperation_t operation     = PORT_READ(in_EXECUTE_IN_OPERATION);
             Ttype_t      type          = PORT_READ(in_EXECUTE_IN_TYPE);
+            _execute_operation->_context_id    = context_id   ;
+            _execute_operation->_front_end_id  = front_end_id ;
+            _execute_operation->_ooo_engine_id = ooo_engine_id;
+            _execute_operation->_packet_id     = packet_id    ;
+            _execute_operation->_operation     = operation    ;
+            _execute_operation->_type          = type         ;
+            _execute_operation->_has_immediat  = PORT_READ(in_EXECUTE_IN_HAS_IMMEDIAT);
+            _execute_operation->_immediat      = PORT_READ(in_EXECUTE_IN_IMMEDIAT    );
+            _execute_operation->_data_ra       = PORT_READ(in_EXECUTE_IN_DATA_RA     );
+            _execute_operation->_data_rb       = PORT_READ(in_EXECUTE_IN_DATA_RB     );
+            _execute_operation->_data_rc       = PORT_READ(in_EXECUTE_IN_DATA_RC     );
+            _execute_operation->_write_rd      = PORT_READ(in_EXECUTE_IN_WRITE_RD    );
+            _execute_operation->_num_reg_rd    = PORT_READ(in_EXECUTE_IN_NUM_REG_RD  );
+            _execute_operation->_write_re      = PORT_READ(in_EXECUTE_IN_WRITE_RE    );
+            _execute_operation->_num_reg_re    = PORT_READ(in_EXECUTE_IN_NUM_REG_RE  );
+            _execute_operation_in->_context_id    = context_id   ;
+            _execute_operation_in->_front_end_id  = front_end_id ;
+            _execute_operation_in->_ooo_engine_id = ooo_engine_id;
+            _execute_operation_in->_packet_id     = packet_id    ;
+            _execute_operation_in->_operation     = operation    ;
+            _execute_operation_in->_type          = type         ;
+            _execute_operation_in->_has_immediat  = PORT_READ(in_EXECUTE_IN_HAS_IMMEDIAT);
+            _execute_operation_in->_immediat      = PORT_READ(in_EXECUTE_IN_IMMEDIAT    );
+            _execute_operation_in->_data_ra       = PORT_READ(in_EXECUTE_IN_DATA_RA     );
+            _execute_operation_in->_data_rb       = PORT_READ(in_EXECUTE_IN_DATA_RB     );
+            _execute_operation_in->_data_rc       = PORT_READ(in_EXECUTE_IN_DATA_RC     );
+            _execute_operation_in->_write_rd      = PORT_READ(in_EXECUTE_IN_WRITE_RD    );
+            _execute_operation_in->_num_reg_rd    = PORT_READ(in_EXECUTE_IN_NUM_REG_RD  );
+            _execute_operation_in->_write_re      = PORT_READ(in_EXECUTE_IN_WRITE_RE    );
+            _execute_operation_in->_num_reg_re    = PORT_READ(in_EXECUTE_IN_NUM_REG_RE  );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * context_id    : %d",_execute_operation_in->_context_id   );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * front_end_id  : %d",_execute_operation_in->_front_end_id );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * ooo_engine_id : %d",_execute_operation_in->_ooo_engine_id);
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * packet_id     : %d",_execute_operation_in->_packet_id    );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * operation     : %d",_execute_operation_in->_operation    );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * type          : %s",toString_type(_execute_operation_in->_type).c_str());
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * has_immediat  : %d",_execute_operation_in->_has_immediat );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * immediat      : %.8x",_execute_operation_in->_immediat     );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_ra       : %.8x",_execute_operation_in->_data_ra      );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rb       : %.8x",_execute_operation_in->_data_rb      );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rc       : %.8x",_execute_operation_in->_data_rc      );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_rd      : %d"  ,_execute_operation_in->_write_rd     );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_rd    : %d"  ,_execute_operation_in->_num_reg_rd   );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * write_re      : %d"  ,_execute_operation_in->_write_re     );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * num_reg_re    : %d"  ,_execute_operation_in->_num_reg_re   );
 #ifdef DEBUG_TEST
             if (type >= _param->_nb_type)
 …
             if (type == TYPE_CUSTOM)
+              {
                 uint32_t num_thread = get_num_thread(context_id   ,_param->_size_context_id,
                                                      front_end_id ,_param->_size_front_end_id,
                                                      ooo_engine_id,_param->_size_ooo_engine_id);
                 (*(_param->_get_custom_information(num_thread)._get_custom_execute_genMoore(operation))) (_execute_operation, execute_register, _execute_param);
+//              uint32_t num_thread = get_num_thread(context_id   ,_param->_size_context_id,
+//                                                   front_end_id ,_param->_size_front_end_id,
+//                                                   ooo_engine_id,_param->_size_ooo_engine_id);
+                (*(_param->_get_custom_information()._get_custom_execute_genMoore(operation))) (_execute_operation_in, execute_register, _execute_param);
+              }
             else
+              (*(_function_execute[type][operation])) (_execute_operation, execute_register, _execute_param);
+              (*(_function_execute[type][operation])) (_execute_operation_in, execute_register, _execute_param);
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    -----------------");
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * latence       : %.8x",_execute_operation_in->_timing._latence);
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * delay         : %.8x",_execute_operation_in->_timing._delay);
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_rd       : %.8x",_execute_operation_in->_data_rd    );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * data_re       : %.8x",_execute_operation_in->_data_re    );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * exception     : %d"  ,_execute_operation_in->_exception  );
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * no_sequence   : %d"  ,_execute_operation_in->_no_sequence);
+            log_printf(TRACE,Functionnal_unit,FUNCTION,"    * address       : %.8x",_execute_operation_in->_address    );
 #ifdef STATISTICS
+            (*_stat_use_functionnal_unit) ++;
+            (*_stat_sum_delay)   += _execute_operation->_timing._delay;
+            (*_stat_sum_latence) += _execute_operation->_timing._latence;
+            if (usage_is_set(_usage,USE_STATISTICS))
+              {
+                (*_stat_use_functionnal_unit) ++;
+                (*_stat_sum_delay)   += _execute_operation_in->_timing._delay;
+                (*_stat_sum_latence) += _execute_operation_in->_timing._latence;
+              }
 #endif
+          }
 …
               for (uint32_t k=0; k<_param->_nb_ooo_engine; k++)
+                {
                   uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
                                                        j,_param->_size_front_end_id,
                                                        k,_param->_size_ooo_engine_id);
+//                uint32_t num_thread = get_num_thread(i,_param->_size_context_id,
+//                                                     j,_param->_size_front_end_id,
+//                                                     k,_param->_size_ooo_engine_id);
                   for (uint32_t x=GROUP_CUSTOM_1; x<GROUP_CUSTOM_8; x++)
+                    {
                       function_execute_end_cycle_t * fct = (_param->_get_custom_information(num_thread)._get_custom_execute_transition(x));
+                      function_execute_end_cycle_t * fct = (_param->_get_custom_information()._get_custom_execute_transition(x));
                       if (fct != NULL)
 …
+            }
+        }
+        if (reg_BUSY_IN and not reg_BUSY_OUT)
+          {
+            reg_BUSY_OUT = reg_BUSY_IN;
+            reg_BUSY_IN  = false;
+            _execute_operation_out->_timing        = _execute_operation_in->_timing       ;
+            _execute_operation_out->_context_id    = _execute_operation_in->_context_id   ;
+            _execute_operation_out->_front_end_id  = _execute_operation_in->_front_end_id ;
+            _execute_operation_out->_ooo_engine_id = _execute_operation_in->_ooo_engine_id;
+            _execute_operation_out->_packet_id     = _execute_operation_in->_packet_id    ;
+            _execute_operation_out->_operation     = _execute_operation_in->_operation    ;
+            _execute_operation_out->_type          = _execute_operation_in->_type         ;
+            _execute_operation_out->_has_immediat  = _execute_operation_in->_has_immediat ;
+            _execute_operation_out->_immediat      = _execute_operation_in->_immediat     ;
+            _execute_operation_out->_data_ra       = _execute_operation_in->_data_ra      ;
+            _execute_operation_out->_data_rb       = _execute_operation_in->_data_rb      ;
+            _execute_operation_out->_data_rc       = _execute_operation_in->_data_rc      ;
+            _execute_operation_out->_data_rd       = _execute_operation_in->_data_rd      ;
+            _execute_operation_out->_data_re       = _execute_operation_in->_data_re      ;
+            _execute_operation_out->_write_rd      = _execute_operation_in->_write_rd     ;
+            _execute_operation_out->_num_reg_rd    = _execute_operation_in->_num_reg_rd   ;
+            _execute_operation_out->_write_re      = _execute_operation_in->_write_re     ;
+            _execute_operation_out->_num_reg_re    = _execute_operation_in->_num_reg_re   ;
+            _execute_operation_out->_exception     = _execute_operation_in->_exception    ;
+            _execute_operation_out->_no_sequence   = _execute_operation_in->_no_sequence  ;
+            _execute_operation_out->_address       = _execute_operation_in->_address      ;
+          }
+        // each cycle : decrease the latence
+        if (reg_BUSY_OUT and (_execute_operation_out->_timing._latence > 0))
+          _execute_operation_out->_timing._latence --;
+      }
-    // each cycle : decrease the latence
-    if (reg_BUSY and (_execute_operation->_timing._latence > 0))
-      _execute_operation->_timing._latence --;
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
 …
 #endif
     log_printf(FUNC,Functionnal_unit,FUNCTION,"End");
+    log_end(Functionnal_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t           size_load_queue    ,
                           execute_timing_t** timing             ,
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t)) :
+    _nb_context              (nb_context            ),
+    _nb_front_end            (nb_front_end          ),
+    _nb_ooo_engine           (nb_ooo_engine         ),
+    _nb_packet               (nb_packet             ),
+    _size_general_data       (size_general_data     ),
+    _nb_general_register     (nb_general_register   ),
+    _size_special_data       (size_special_data     ),
+    _nb_special_register     (nb_special_register   ),
+    _size_store_queue        (size_store_queue      ),
+    _size_load_queue         (size_load_queue       ),
+    _size_context_id         (log2(nb_context      )),
+    _size_front_end_id       (log2(nb_front_end    )),
+    _size_ooo_engine_id      (log2(nb_ooo_engine   )),
+    _size_packet_id          (log2(nb_packet       )),
+    _size_general_register   (log2(nb_general_register)),
+    _size_special_register   (log2(nb_special_register)),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_packet_id     (_size_packet_id     > 0),
+    _have_port_load_queue_ptr(_size_load_queue    > 1),
+    _have_groupe_MAC         ( (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MAC  ]._latence > 0) or
+                               (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MACRC]._latence > 0) or
+                               (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MSB  ]._latence > 0))
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                          bool               is_toplevel)
+  {
     log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
+    _timing                 = timing;
+    _nb_context              = nb_context            ;
+    _nb_front_end            = nb_front_end          ;
+    _nb_ooo_engine           = nb_ooo_engine         ;
+    _nb_packet               = nb_packet             ;
+//  _size_general_data       = size_general_data     ;
+//  _size_special_data       = size_special_data     ;
+//  _nb_general_register     = nb_general_register   ;
+//  _nb_special_register     = nb_special_register   ;
+//  _size_store_queue        = size_store_queue      ;
+//  _size_load_queue         = size_load_queue       ;
+//  _size_context_id         = log2(nb_context         );
+//  _size_front_end_id       = log2(nb_front_end       );
+//  _size_ooo_engine_id      = log2(nb_ooo_engine      );
+//  _size_packet_id          = log2(nb_packet          );
+//  _size_general_register   = log2(nb_general_register);
+//  _size_special_register   = log2(nb_special_register);
+//  _have_port_context_id    = _size_context_id    > 0;
+//  _have_port_front_end_id  = _size_front_end_id  > 0;
+//  _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+//  _have_port_packet_id     = _size_packet_id     > 0;
+//  _have_port_load_queue_ptr= _size_load_queue    > 1;
+    _have_groupe_MAC         = ( (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MAC  ]._latence > 0) or
+                                 (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MACRC]._latence > 0) or
+                                 (timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MSB  ]._latence > 0));
+    _timing                  = timing;
     if (get_custom_information == NULL)
 …
     test();
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(nb_context         );
+        _size_front_end_id       = log2(nb_front_end       );
+        _size_ooo_engine_id      = log2(nb_ooo_engine      );
+        _size_rob_ptr            = log2(nb_packet          );
+        _size_general_register   = log2(nb_general_register);
+        _size_special_register   = log2(nb_special_register);
+        _size_general_data       = size_general_data     ;
+        _size_special_data       = size_special_data     ;
+        _size_general_register   = log2(nb_general_register);
+        _size_special_register   = log2(nb_special_register);
+        _size_load_queue_ptr     = log2(size_load_queue );
+        _size_store_queue_ptr    = log2(size_store_queue);
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        _have_port_load_queue_ptr= _size_load_queue_ptr> 0;
+        copy();
+      }
     log_printf(FUNC,Functionnal_unit,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Functionnal_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _nb_context              (param._nb_context             ),
+//     _nb_front_end            (param._nb_front_end           ),
+//     _nb_ooo_engine           (param._nb_ooo_engine          ),
+//     _nb_packet               (param._nb_packet              ),
+//     _size_general_data       (param._size_general_data      ),
+//     _nb_general_register     (param._nb_general_register    ),
+//     _size_special_data       (param._size_special_data      ),
+//     _nb_special_register     (param._nb_special_register    ),
+//     _size_store_queue        (param._size_store_queue       ),
+//     _size_load_queue         (param._size_load_queue        ),
+//     _size_context_id         (param._size_context_id        ),
+//     _size_front_end_id       (param._size_front_end_id      ),
+//     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+//     _size_packet_id          (param._size_packet_id         ),
+//     _size_general_register   (param._size_general_register  ),
+//     _size_special_register   (param._size_special_register  ),
+//     _have_port_context_id    (param._have_port_context_id   ),
+//     _have_port_front_end_id  (param._have_port_front_end_id ),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+//     _have_port_packet_id     (param._have_port_packet_id    ),
+//     _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
+//     _have_groupe_MAC         (param._have_groupe_MAC        )
+//   {
+//     log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
+//     _timing                 = param._timing;
+//     _get_custom_information = param._get_custom_information;
+//     test();
+//     log_printf(FUNC,Functionnal_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Functionnal_unit::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _nb_context              (param._nb_context             ),
+    _nb_front_end            (param._nb_front_end           ),
+    _nb_ooo_engine           (param._nb_ooo_engine          ),
+    _nb_packet               (param._nb_packet              ),
+    _size_general_data       (param._size_general_data      ),
+    _nb_general_register     (param._nb_general_register    ),
+    _size_special_data       (param._size_special_data      ),
+    _nb_special_register     (param._nb_special_register    ),
+    _size_store_queue        (param._size_store_queue       ),
+    _size_load_queue         (param._size_load_queue        ),
+    _size_context_id         (param._size_context_id        ),
+    _size_front_end_id       (param._size_front_end_id      ),
+    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+    _size_packet_id          (param._size_packet_id         ),
+    _size_general_register   (param._size_general_register  ),
+    _size_special_register   (param._size_special_register  ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_packet_id     (param._have_port_packet_id    ),
+    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
+    _have_groupe_MAC         (param._have_groupe_MAC        )
+#define FUNCTION "Functionnal_unit::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");
-    _timing                 = param._timing;
-    _get_custom_information = param._get_custom_information;
-    test();
     log_printf(FUNC,Functionnal_unit,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Functionnal_unit::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Functionnal_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Functionnal_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Parameters_msg_error.cpp

-              r81
+              r88
       for (uint32_t j=0; j<_nb_operation; j++)
         if (_timing[i][j]._delay != _timing[i][j]._latence)
           test.error("For the type '"+toString(i)+"', and the operation '"+toString(j)+"', the delay and the latence must be equal.");
+          test.error(toString(_("For the type '%d', and the operation '%d', the delay and the latence must be equal.\n"),i,j));
     if (_have_groupe_MAC and ((_timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MAC  ]._latence == 0) or
                               (_timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MACRC]._latence == 0) or
                               (_timing[TYPE_SPECIAL][OPERATION_SPECIAL_L_MSB  ]._latence == 0)))
       test.error("The functionnal unit implement a MAC unit, the latence to operation OPERATION_ALU_L_MAC, OPERATION_ALU_L_MACRC and OPERATION_ALU_L_MSB must be higher than 0.");
+      test.error("The functionnal unit implement a MAC unit, the latence to operation OPERATION_ALU_L_MAC, OPERATION_ALU_L_MACRC and OPERATION_ALU_L_MSB must be higher than 0.\n");
     log_printf(FUNC,Functionnal_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/src/Parameters_print.cpp

-              r81
+              r88
     xml.singleton_begin("nb_packet          "); xml.attribut("value",toString(_nb_packet          )); xml.singleton_end();
     xml.singleton_begin("size_general_data  "); xml.attribut("value",toString(_size_general_data  )); xml.singleton_end();
     xml.singleton_begin("nb_general_register"); xml.attribut("value",toString(_nb_general_register)); xml.singleton_end();
+//  xml.singleton_begin("nb_general_register"); xml.attribut("value",toString(_nb_general_register)); xml.singleton_end();
     xml.singleton_begin("size_special_data  "); xml.attribut("value",toString(_size_special_data  )); xml.singleton_end();
     xml.singleton_begin("nb_special_register"); xml.attribut("value",toString(_nb_special_register)); xml.singleton_end();
+//  xml.singleton_begin("nb_special_register"); xml.attribut("value",toString(_nb_special_register)); xml.singleton_end();
     xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Load_store_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/configuration.cfg

r81	r88
6	6	2 2 +1 # speculative_load {none,access,commit,bypass}
7	7	0 0 +1 # bypass_memory
	8	1 1 +1 # nb_cache_port
	9	1 1 +1 # nb_inst_memory
8	10	2 2 2 # nb_context 1 1 2
9	11	2 2 2 # nb_front_end 1 1 2

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/include/Memory.h

r81	r88
287	287	<< i->_data_old << " -> "
288	288	<< i->_data_new << std::endl
289		<< std::~~hex~~;
	289	<< std::dec;
290	290	}
291	291	}

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/src/main.cpp

-              r81
+              r88
        << " - speculative_load        (uint32_t)" << endl
        << " - nb_bypass_memory        (uint32_t)" << endl
+       << " - nb_cache_port           (uint32_t)" << endl
+       << " - nb_inst_memory          (uint32_t)" << endl
        << " - nb_context              (uint32_t)" << endl
        << " - nb_front_end            (uint32_t)" << endl
 …
         const Tspeculative_load_t _speculative_load        = fromString<Tspeculative_load_t>(argv[x++]);
         const uint32_t            _nb_bypass_memory        = atoi(argv[x++]);
+        const uint32_t            _nb_cache_port           = atoi(argv[x++]);
+        const uint32_t            _nb_inst_memory          = atoi(argv[x++]);
         const uint32_t            _nb_context              = atoi(argv[x++]);
         const uint32_t            _nb_front_end            = atoi(argv[x++]);
 …
                _speculative_load       ,
                _nb_bypass_memory       ,
+               _nb_cache_port          ,
+               _nb_inst_memory         ,
                _nb_context             ,
                _nb_front_end           ,
 …
                _size_special_data      ,
                _nb_general_register    ,
+               _nb_special_register    );
+               _nb_special_register    ,
+               true //is_toplevel
+               );
             cout << param->print(1);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/src/test2.cpp

-              r82
+              r88
 #include <queue>
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/SelfTest/include/test.h"
+#include "Behavioural/include/Allocation.h"
 //===================================================================={test}
 …
          SPECULATIVE_LOAD_COMMIT,  //_speculative_load
 ,  //_nb_bypass_memory
+,  //_nb_cache_port
+,  //_nb_inst_memory
 ,  //_nb_context
 ,  //_nb_front_end
 …
 , //_size_special_data
 , //_nb_general_register
+  //_nb_special_register
+, //_nb_special_register
+         true //is_toplevel
         );
 …
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,0);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Load_store_unit * _Load_store_unit = new Load_store_unit (name.c_str(),
 …
 #endif
                                                             _param,
                                                             USE_ALL);
+                                                            _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tcontrol_t>                  * in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
+  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_VAL                   = new sc_signal<Tcontrol_t        > (rename.c_str());
+  sc_signal<Tcontrol_t        > *  out_MEMORY_IN_ACK                   = new sc_signal<Tcontrol_t        > (rename.c_str());
+  sc_signal<Tcontext_t        > *   in_MEMORY_IN_CONTEXT_ID            = new sc_signal<Tcontext_t        > (rename.c_str());
+  sc_signal<Tcontext_t        > *   in_MEMORY_IN_FRONT_END_ID          = new sc_signal<Tcontext_t        > (rename.c_str());
+  sc_signal<Tcontext_t        > *   in_MEMORY_IN_OOO_ENGINE_ID         = new sc_signal<Tcontext_t        > (rename.c_str());
+  sc_signal<Tpacket_t         > *   in_MEMORY_IN_PACKET_ID             = new sc_signal<Tpacket_t         > (rename.c_str());
+  sc_signal<Toperation_t      > *   in_MEMORY_IN_OPERATION             = new sc_signal<Toperation_t      > (rename.c_str());
+  sc_signal<Ttype_t           > *   in_MEMORY_IN_TYPE                  = new sc_signal<Ttype_t           > (rename.c_str());
+  sc_signal<Tlsq_ptr_t        > *   in_MEMORY_IN_STORE_QUEUE_PTR_WRITE = new sc_signal<Tlsq_ptr_t        > (rename.c_str());
+  sc_signal<Tlsq_ptr_t        > *   in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE  = new sc_signal<Tlsq_ptr_t        > (rename.c_str());
+  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_HAS_IMMEDIAT          = new sc_signal<Tcontrol_t        > (rename.c_str());
+  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_IMMEDIAT              = new sc_signal<Tgeneral_data_t   > (rename.c_str());
+  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_DATA_RA               = new sc_signal<Tgeneral_data_t   > (rename.c_str());
+  sc_signal<Tgeneral_data_t   > *   in_MEMORY_IN_DATA_RB               = new sc_signal<Tgeneral_data_t   > (rename.c_str());
+  sc_signal<Tspecial_data_t   > *   in_MEMORY_IN_DATA_RC               = new sc_signal<Tspecial_data_t   > (rename.c_str());
+  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RD              = new sc_signal<Tcontrol_t        > (rename.c_str());
+  sc_signal<Tgeneral_address_t> *   in_MEMORY_IN_NUM_REG_RD            = new sc_signal<Tgeneral_address_t> (rename.c_str());
+  sc_signal<Tcontrol_t        > *   in_MEMORY_IN_WRITE_RE              = new sc_signal<Tcontrol_t        > (rename.c_str());
+  sc_signal<Tspecial_address_t> *   in_MEMORY_IN_NUM_REG_RE            = new sc_signal<Tspecial_address_t> (rename.c_str());
+  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_VAL           = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tcontrol_t        > *   in_MEMORY_OUT_ACK           = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tcontext_t        > *  out_MEMORY_OUT_CONTEXT_ID    = new sc_signal<Tcontext_t        >(rename.c_str());
+  sc_signal<Tcontext_t        > *  out_MEMORY_OUT_FRONT_END_ID  = new sc_signal<Tcontext_t        >(rename.c_str());
+  sc_signal<Tcontext_t        > *  out_MEMORY_OUT_OOO_ENGINE_ID = new sc_signal<Tcontext_t        >(rename.c_str());
+  sc_signal<Tpacket_t         > *  out_MEMORY_OUT_PACKET_ID     = new sc_signal<Tpacket_t         >(rename.c_str());
+//   sc_signal<Toperation_t      > *  out_MEMORY_OUT_OPERATION     = new sc_signal<Toperation_t      >(rename.c_str());
+  sc_signal<Ttype_t           > *  out_MEMORY_OUT_TYPE          = new sc_signal<Ttype_t           >(rename.c_str());
+  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RD      = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tgeneral_address_t> *  out_MEMORY_OUT_NUM_REG_RD    = new sc_signal<Tgeneral_address_t>(rename.c_str());
+  sc_signal<Tgeneral_data_t   > *  out_MEMORY_OUT_DATA_RD       = new sc_signal<Tgeneral_data_t   >(rename.c_str());
+  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_WRITE_RE      = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tspecial_address_t> *  out_MEMORY_OUT_NUM_REG_RE    = new sc_signal<Tspecial_address_t>(rename.c_str());
+  sc_signal<Tspecial_data_t   > *  out_MEMORY_OUT_DATA_RE       = new sc_signal<Tspecial_data_t   >(rename.c_str());
+  sc_signal<Texception_t      > *  out_MEMORY_OUT_EXCEPTION     = new sc_signal<Texception_t      >(rename.c_str());
+  sc_signal<Tcontrol_t        > *  out_MEMORY_OUT_NO_SEQUENCE   = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tgeneral_data_t   > *  out_MEMORY_OUT_ADDRESS       = new sc_signal<Tgeneral_data_t   >(rename.c_str());
+  sc_signal<Tcontrol_t        > * out_DCACHE_REQ_VAL        = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tcontrol_t        > *  in_DCACHE_REQ_ACK        = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tcontext_t        > * out_DCACHE_REQ_CONTEXT_ID = new sc_signal<Tcontext_t        >(rename.c_str());
+  sc_signal<Tpacket_t         > * out_DCACHE_REQ_PACKET_ID  = new sc_signal<Tpacket_t         >(rename.c_str());
+  sc_signal<Tdcache_address_t > * out_DCACHE_REQ_ADDRESS    = new sc_signal<Tdcache_address_t >(rename.c_str());
+  sc_signal<Tdcache_type_t    > * out_DCACHE_REQ_TYPE       = new sc_signal<Tdcache_type_t    >(rename.c_str());
+  sc_signal<Tdcache_data_t    > * out_DCACHE_REQ_WDATA      = new sc_signal<Tdcache_data_t    >(rename.c_str());
+  sc_signal<Tcontrol_t        > *  in_DCACHE_RSP_VAL        = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tcontrol_t        > * out_DCACHE_RSP_ACK        = new sc_signal<Tcontrol_t        >(rename.c_str());
+  sc_signal<Tcontext_t        > *  in_DCACHE_RSP_CONTEXT_ID = new sc_signal<Tcontext_t        >(rename.c_str());
+  sc_signal<Tpacket_t         > *  in_DCACHE_RSP_PACKET_ID  = new sc_signal<Tpacket_t         >(rename.c_str());
+  sc_signal<Tdcache_data_t    > *  in_DCACHE_RSP_RDATA      = new sc_signal<Tdcache_data_t    >(rename.c_str());
+  sc_signal<Tdcache_error_t   > *  in_DCACHE_RSP_ERROR      = new sc_signal<Tdcache_error_t   >(rename.c_str());
+  sc_signal<Tcontrol_t        > ** out_BYPASS_MEMORY_VAL           = new sc_signal<Tcontrol_t        > * [_param->_nb_bypass_memory];
+  sc_signal<Tcontext_t        > ** out_BYPASS_MEMORY_OOO_ENGINE_ID = new sc_signal<Tcontext_t        > * [_param->_nb_bypass_memory];
+  sc_signal<Tgeneral_address_t> ** out_BYPASS_MEMORY_NUM_REG       = new sc_signal<Tgeneral_address_t> * [_param->_nb_bypass_memory];
+  sc_signal<Tgeneral_data_t   > ** out_BYPASS_MEMORY_DATA          = new sc_signal<Tgeneral_data_t   > * [_param->_nb_bypass_memory];
+  for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
+    {
+      out_BYPASS_MEMORY_VAL           [i] = new sc_signal<Tcontrol_t        >(rename.c_str());
+      out_BYPASS_MEMORY_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t        >(rename.c_str());
+      out_BYPASS_MEMORY_NUM_REG       [i] = new sc_signal<Tgeneral_address_t>(rename.c_str());
+      out_BYPASS_MEMORY_DATA          [i] = new sc_signal<Tgeneral_data_t   >(rename.c_str());
+    }
+    // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_VAL                  ," in_MEMORY_IN_VAL                  ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_IN_ACK                  ,"out_MEMORY_IN_ACK                  ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_CONTEXT_ID           ," in_MEMORY_IN_CONTEXT_ID           ",Tcontext_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_FRONT_END_ID         ," in_MEMORY_IN_FRONT_END_ID         ",Tcontext_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_OOO_ENGINE_ID        ," in_MEMORY_IN_OOO_ENGINE_ID        ",Tcontext_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_PACKET_ID            ," in_MEMORY_IN_PACKET_ID            ",Tpacket_t         ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_OPERATION            ," in_MEMORY_IN_OPERATION            ",Toperation_t      ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_TYPE                 ," in_MEMORY_IN_TYPE                 ",Ttype_t           ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE," in_MEMORY_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ," in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ",Tlsq_ptr_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_HAS_IMMEDIAT         ," in_MEMORY_IN_HAS_IMMEDIAT         ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_IMMEDIAT             ," in_MEMORY_IN_IMMEDIAT             ",Tgeneral_data_t   ,_param->_nb_inst_memory); // memory address
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_DATA_RA              ," in_MEMORY_IN_DATA_RA              ",Tgeneral_data_t   ,_param->_nb_inst_memory); // memory address
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_DATA_RB              ," in_MEMORY_IN_DATA_RB              ",Tgeneral_data_t   ,_param->_nb_inst_memory); // data        (store)
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_DATA_RC              ," in_MEMORY_IN_DATA_RC              ",Tspecial_data_t   ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_WRITE_RD             ," in_MEMORY_IN_WRITE_RD             ",Tcontrol_t        ,_param->_nb_inst_memory); // = (operation==load)
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_NUM_REG_RD           ," in_MEMORY_IN_NUM_REG_RD           ",Tgeneral_address_t,_param->_nb_inst_memory); // destination (load)
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_WRITE_RE             ," in_MEMORY_IN_WRITE_RE             ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_IN_NUM_REG_RE           ," in_MEMORY_IN_NUM_REG_RE           ",Tspecial_address_t,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_VAL                 ,"out_MEMORY_OUT_VAL                 ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL( in_MEMORY_OUT_ACK                 ," in_MEMORY_OUT_ACK                 ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_CONTEXT_ID          ,"out_MEMORY_OUT_CONTEXT_ID          ",Tcontext_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_FRONT_END_ID        ,"out_MEMORY_OUT_FRONT_END_ID        ",Tcontext_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_OOO_ENGINE_ID       ,"out_MEMORY_OUT_OOO_ENGINE_ID       ",Tcontext_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_PACKET_ID           ,"out_MEMORY_OUT_PACKET_ID           ",Tpacket_t         ,_param->_nb_inst_memory);
+//ALLOC1_SC_SIGNAL(out_MEMORY_OUT_OPERATION           ,"out_MEMORY_OUT_OPERATION           ",Toperation_t      ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_TYPE                ,"out_MEMORY_OUT_TYPE                ",Ttype_t           ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_WRITE_RD            ,"out_MEMORY_OUT_WRITE_RD            ",Tcontrol_t        ,_param->_nb_inst_memory); // = (operation==load)
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_NUM_REG_RD          ,"out_MEMORY_OUT_NUM_REG_RD          ",Tgeneral_address_t,_param->_nb_inst_memory); // destination (load)
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_DATA_RD             ,"out_MEMORY_OUT_DATA_RD             ",Tgeneral_data_t   ,_param->_nb_inst_memory); // data        (load)
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_WRITE_RE            ,"out_MEMORY_OUT_WRITE_RE            ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_NUM_REG_RE          ,"out_MEMORY_OUT_NUM_REG_RE          ",Tspecial_address_t,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_DATA_RE             ,"out_MEMORY_OUT_DATA_RE             ",Tspecial_data_t   ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_EXCEPTION           ,"out_MEMORY_OUT_EXCEPTION           ",Texception_t      ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_NO_SEQUENCE         ,"out_MEMORY_OUT_NO_SEQUENCE         ",Tcontrol_t        ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_MEMORY_OUT_ADDRESS             ,"out_MEMORY_OUT_ADDRESS             ",Tgeneral_data_t   ,_param->_nb_inst_memory);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_VAL                 ,"out_DCACHE_REQ_VAL                 ",Tcontrol_t        ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL( in_DCACHE_REQ_ACK                 ," in_DCACHE_REQ_ACK                 ",Tcontrol_t        ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_CONTEXT_ID          ,"out_DCACHE_REQ_CONTEXT_ID          ",Tcontext_t        ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_PACKET_ID           ,"out_DCACHE_REQ_PACKET_ID           ",Tpacket_t         ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_ADDRESS             ,"out_DCACHE_REQ_ADDRESS             ",Tdcache_address_t ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_TYPE                ,"out_DCACHE_REQ_TYPE                ",Tdcache_type_t    ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_WDATA               ,"out_DCACHE_REQ_WDATA               ",Tdcache_data_t    ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_VAL                 ," in_DCACHE_RSP_VAL                 ",Tcontrol_t        ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_DCACHE_RSP_ACK                 ,"out_DCACHE_RSP_ACK                 ",Tcontrol_t        ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_CONTEXT_ID          ," in_DCACHE_RSP_CONTEXT_ID          ",Tcontext_t        ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_PACKET_ID           ," in_DCACHE_RSP_PACKET_ID           ",Tpacket_t         ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_RDATA               ," in_DCACHE_RSP_RDATA               ",Tdcache_data_t    ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_ERROR               ," in_DCACHE_RSP_ERROR               ",Tdcache_error_t   ,_param->_nb_cache_port);
+  ALLOC1_SC_SIGNAL(out_BYPASS_MEMORY_VAL              ,"out_BYPASS_MEMORY_VAL              ",Tcontrol_t        ,_param->_nb_bypass_memory);
+  ALLOC1_SC_SIGNAL(out_BYPASS_MEMORY_OOO_ENGINE_ID    ,"out_BYPASS_MEMORY_OOO_ENGINE_ID    ",Tcontext_t        ,_param->_nb_bypass_memory);
+  ALLOC1_SC_SIGNAL(out_BYPASS_MEMORY_NUM_REG          ,"out_BYPASS_MEMORY_NUM_REG          ",Tgeneral_address_t,_param->_nb_bypass_memory);
+  ALLOC1_SC_SIGNAL(out_BYPASS_MEMORY_DATA             ,"out_BYPASS_MEMORY_DATA             ",Tgeneral_data_t   ,_param->_nb_bypass_memory);
   /********************************************************
 …
   (*(_Load_store_unit->in_NRESET))       (*(in_NRESET));
   (*(_Load_store_unit-> in_MEMORY_IN_VAL                  ))(*( in_MEMORY_IN_VAL                  ));
   (*(_Load_store_unit->out_MEMORY_IN_ACK                  ))(*(out_MEMORY_IN_ACK                  ));
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_VAL                  ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_IN_ACK                  ,_param->_nb_inst_memory);
   if (_param->_have_port_context_id)
     (*(_Load_store_unit-> in_MEMORY_IN_CONTEXT_ID           ))(*( in_MEMORY_IN_CONTEXT_ID           ));
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_CONTEXT_ID           ,_param->_nb_inst_memory);
   if (_param->_have_port_front_end_id)
+    (*(_Load_store_unit-> in_MEMORY_IN_FRONT_END_ID         ))(*( in_MEMORY_IN_FRONT_END_ID         ));
+  if (_param->_have_port_ooo_engine_id)
+    (*(_Load_store_unit-> in_MEMORY_IN_OOO_ENGINE_ID        ))(*( in_MEMORY_IN_OOO_ENGINE_ID        ));
+  if (_param->_have_port_packet_id)
+    (*(_Load_store_unit-> in_MEMORY_IN_PACKET_ID            ))(*( in_MEMORY_IN_PACKET_ID            ));
+  (*(_Load_store_unit-> in_MEMORY_IN_OPERATION            ))(*( in_MEMORY_IN_OPERATION            ));
+  (*(_Load_store_unit-> in_MEMORY_IN_TYPE                 ))(*( in_MEMORY_IN_TYPE                 ));
+  (*(_Load_store_unit-> in_MEMORY_IN_STORE_QUEUE_PTR_WRITE))(*( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE));
+  if (_param->_have_port_load_queue_ptr)
+  (*(_Load_store_unit-> in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ))(*( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ));
+  (*(_Load_store_unit-> in_MEMORY_IN_HAS_IMMEDIAT         ))(*( in_MEMORY_IN_HAS_IMMEDIAT         ));
+  (*(_Load_store_unit-> in_MEMORY_IN_IMMEDIAT             ))(*( in_MEMORY_IN_IMMEDIAT             ));
+  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RA              ))(*( in_MEMORY_IN_DATA_RA              ));
+  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RB              ))(*( in_MEMORY_IN_DATA_RB              ));
+  (*(_Load_store_unit-> in_MEMORY_IN_DATA_RC              ))(*( in_MEMORY_IN_DATA_RC              ));
+  (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RD             ))(*( in_MEMORY_IN_WRITE_RD             ));
+  (*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RD           ))(*( in_MEMORY_IN_NUM_REG_RD           ));
+  (*(_Load_store_unit-> in_MEMORY_IN_WRITE_RE             ))(*( in_MEMORY_IN_WRITE_RE             ));
+  (*(_Load_store_unit-> in_MEMORY_IN_NUM_REG_RE           ))(*( in_MEMORY_IN_NUM_REG_RE           ));
+  (*(_Load_store_unit->out_MEMORY_OUT_VAL           ))(*(out_MEMORY_OUT_VAL           ));
+  (*(_Load_store_unit-> in_MEMORY_OUT_ACK           ))(*( in_MEMORY_OUT_ACK           ));
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_FRONT_END_ID         ,_param->_nb_inst_memory);
+  if (_param->_have_port_ooo_engine_id)
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_OOO_ENGINE_ID        ,_param->_nb_inst_memory);
+  if (_param->_have_port_rob_ptr)
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_PACKET_ID            ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_OPERATION            ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_TYPE                 ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_HAS_IMMEDIAT         ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_IMMEDIAT             ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_DATA_RA              ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_DATA_RB              ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_DATA_RC              ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_WRITE_RD             ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_NUM_REG_RD           ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_WRITE_RE             ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_IN_NUM_REG_RE           ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_VAL          ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_MEMORY_OUT_ACK          ,_param->_nb_inst_memory);
   if (_param->_have_port_context_id)
     (*(_Load_store_unit->out_MEMORY_OUT_CONTEXT_ID    ))(*(out_MEMORY_OUT_CONTEXT_ID    ));
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_CONTEXT_ID   ,_param->_nb_inst_memory);
   if (_param->_have_port_front_end_id)
     (*(_Load_store_unit->out_MEMORY_OUT_FRONT_END_ID  ))(*(out_MEMORY_OUT_FRONT_END_ID  ));
   if (_param->_have_port_ooo_engine_id)
     (*(_Load_store_unit->out_MEMORY_OUT_OOO_ENGINE_ID ))(*(out_MEMORY_OUT_OOO_ENGINE_ID ));
   if (_param->_have_port_packet_id)
     (*(_Load_store_unit->out_MEMORY_OUT_PACKET_ID     ))(*(out_MEMORY_OUT_PACKET_ID     ));
 //   (*(_Load_store_unit->out_MEMORY_OUT_OPERATION     ))(*(out_MEMORY_OUT_OPERATION     ));
   (*(_Load_store_unit->out_MEMORY_OUT_TYPE          ))(*(out_MEMORY_OUT_TYPE          ));
   (*(_Load_store_unit->out_MEMORY_OUT_WRITE_RD      ))(*(out_MEMORY_OUT_WRITE_RD      ));
   (*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RD    ))(*(out_MEMORY_OUT_NUM_REG_RD    ));
   (*(_Load_store_unit->out_MEMORY_OUT_DATA_RD       ))(*(out_MEMORY_OUT_DATA_RD       ));
   (*(_Load_store_unit->out_MEMORY_OUT_WRITE_RE      ))(*(out_MEMORY_OUT_WRITE_RE      ));
   (*(_Load_store_unit->out_MEMORY_OUT_NUM_REG_RE    ))(*(out_MEMORY_OUT_NUM_REG_RE    ));
   (*(_Load_store_unit->out_MEMORY_OUT_DATA_RE       ))(*(out_MEMORY_OUT_DATA_RE       ));
   (*(_Load_store_unit->out_MEMORY_OUT_EXCEPTION     ))(*(out_MEMORY_OUT_EXCEPTION     ));
   (*(_Load_store_unit->out_MEMORY_OUT_NO_SEQUENCE   ))(*(out_MEMORY_OUT_NO_SEQUENCE   ));
   (*(_Load_store_unit->out_MEMORY_OUT_ADDRESS       ))(*(out_MEMORY_OUT_ADDRESS       ));
   (*(_Load_store_unit->out_DCACHE_REQ_VAL       ))(*(out_DCACHE_REQ_VAL       ));
   (*(_Load_store_unit-> in_DCACHE_REQ_ACK       ))(*( in_DCACHE_REQ_ACK       ));
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_FRONT_END_ID ,_param->_nb_inst_memory);
+  if (_param->_have_port_ooo_engine_id)
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_OOO_ENGINE_ID,_param->_nb_inst_memory);
+  if (_param->_have_port_rob_ptr)
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_PACKET_ID    ,_param->_nb_inst_memory);
+//INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_OPERATION    ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_TYPE         ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_WRITE_RD     ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_NUM_REG_RD   ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_DATA_RD      ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_WRITE_RE     ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_NUM_REG_RE   ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_DATA_RE      ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_EXCEPTION    ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_NO_SEQUENCE  ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_MEMORY_OUT_ADDRESS      ,_param->_nb_inst_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_REQ_VAL        ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_DCACHE_REQ_ACK        ,_param->_nb_cache_port);
   if (_param->_have_port_dcache_context_id)
     (*(_Load_store_unit->out_DCACHE_REQ_CONTEXT_ID))(*(out_DCACHE_REQ_CONTEXT_ID));
   (*(_Load_store_unit->out_DCACHE_REQ_PACKET_ID ))(*(out_DCACHE_REQ_PACKET_ID ));
   (*(_Load_store_unit->out_DCACHE_REQ_ADDRESS   ))(*(out_DCACHE_REQ_ADDRESS   ));
   (*(_Load_store_unit->out_DCACHE_REQ_TYPE      ))(*(out_DCACHE_REQ_TYPE      ));
   (*(_Load_store_unit->out_DCACHE_REQ_WDATA     ))(*(out_DCACHE_REQ_WDATA     ));
   (*(_Load_store_unit-> in_DCACHE_RSP_VAL       ))(*( in_DCACHE_RSP_VAL       ));
   (*(_Load_store_unit->out_DCACHE_RSP_ACK       ))(*(out_DCACHE_RSP_ACK       ));
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_REQ_CONTEXT_ID ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_REQ_PACKET_ID  ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_REQ_ADDRESS    ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_REQ_TYPE       ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_REQ_WDATA      ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_DCACHE_RSP_VAL        ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_DCACHE_RSP_ACK        ,_param->_nb_cache_port);
   if (_param->_have_port_dcache_context_id)
+    (*(_Load_store_unit-> in_DCACHE_RSP_CONTEXT_ID))(*( in_DCACHE_RSP_CONTEXT_ID));
+  (*(_Load_store_unit-> in_DCACHE_RSP_PACKET_ID ))(*( in_DCACHE_RSP_PACKET_ID ));
+  (*(_Load_store_unit-> in_DCACHE_RSP_RDATA     ))(*( in_DCACHE_RSP_RDATA     ));
+  (*(_Load_store_unit-> in_DCACHE_RSP_ERROR     ))(*( in_DCACHE_RSP_ERROR     ));
+    {
+      for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
+        {
+          (*(_Load_store_unit->out_BYPASS_MEMORY_VAL           [i]))(*(out_BYPASS_MEMORY_VAL           [i]));
+          if (_param->_have_port_ooo_engine_id)
+            (*(_Load_store_unit->out_BYPASS_MEMORY_OOO_ENGINE_ID [i]))(*(out_BYPASS_MEMORY_OOO_ENGINE_ID [i]));
+          (*(_Load_store_unit->out_BYPASS_MEMORY_NUM_REG       [i]))(*(out_BYPASS_MEMORY_NUM_REG       [i]));
+          (*(_Load_store_unit->out_BYPASS_MEMORY_DATA          [i]))(*(out_BYPASS_MEMORY_DATA          [i]));
+        }
+    }
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_DCACHE_RSP_CONTEXT_ID ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_DCACHE_RSP_PACKET_ID  ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_DCACHE_RSP_RDATA      ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit, in_DCACHE_RSP_ERROR      ,_param->_nb_cache_port);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_BYPASS_MEMORY_VAL           ,_param->_nb_bypass_memory);
+  if (_param->_have_port_ooo_engine_id)
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_BYPASS_MEMORY_OOO_ENGINE_ID ,_param->_nb_bypass_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_BYPASS_MEMORY_NUM_REG       ,_param->_nb_bypass_memory);
+  INSTANCE1_SC_SIGNAL(_Load_store_unit,out_BYPASS_MEMORY_DATA          ,_param->_nb_bypass_memory);
   cout << "<" << name << "> Start Simulation ............" << endl;
   Time * _time = new Time();
 …
   LABEL("Initialisation");
   in_MEMORY_IN_VAL ->write(0);
   in_MEMORY_OUT_ACK->write(0);
   in_DCACHE_REQ_ACK->write(0);
   in_DCACHE_RSP_VAL->write(0);
+  in_MEMORY_IN_VAL [0]->write(0);
+  in_MEMORY_OUT_ACK[0]->write(0);
+  in_DCACHE_REQ_ACK[0]->write(0);
+  in_DCACHE_RSP_VAL[0]->write(0);
   in_NRESET        ->write(0);
 …
                     can_execute &= not load_queue_use  [fifo_request.top()._load_queue_ptr_write];
+                }
               in_MEMORY_IN_VAL ->write(can_execute);
+              in_MEMORY_IN_VAL [0]->write(can_execute);
               if (not fifo_request.empty())
+                {
                   if (_param->_have_port_context_id)
                     in_MEMORY_IN_CONTEXT_ID           ->write (fifo_request.top()._context_id           );
+                    in_MEMORY_IN_CONTEXT_ID           [0]->write (fifo_request.top()._context_id           );
                   if (_param->_have_port_front_end_id)
                     in_MEMORY_IN_FRONT_END_ID         ->write (fifo_request.top()._front_end_id         );
+                    in_MEMORY_IN_FRONT_END_ID         [0]->write (fifo_request.top()._front_end_id         );
                   if (_param->_have_port_ooo_engine_id)
                     in_MEMORY_IN_OOO_ENGINE_ID        ->write (fifo_request.top()._ooo_engine_id        );
                   if (_param->_have_port_packet_id)
                     in_MEMORY_IN_PACKET_ID            ->write (fifo_request.top()._packet_id            );
                   in_MEMORY_IN_OPERATION            ->write (fifo_request.top()._operation            );
                   in_MEMORY_IN_TYPE                 ->write (fifo_request.top()._type                 );
                   in_MEMORY_IN_STORE_QUEUE_PTR_WRITE->write (fifo_request.top()._store_queue_ptr_write);
+                    in_MEMORY_IN_OOO_ENGINE_ID        [0]->write (fifo_request.top()._ooo_engine_id        );
+                  if (_param->_have_port_rob_ptr)
+                    in_MEMORY_IN_PACKET_ID            [0]->write (fifo_request.top()._packet_id            );
+                  in_MEMORY_IN_OPERATION            [0]->write (fifo_request.top()._operation            );
+                  in_MEMORY_IN_TYPE                 [0]->write (fifo_request.top()._type                 );
+                  in_MEMORY_IN_STORE_QUEUE_PTR_WRITE[0]->write (fifo_request.top()._store_queue_ptr_write);
                   if (_param->_have_port_load_queue_ptr)
                   in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ->write (fifo_request.top()._load_queue_ptr_write );
                   in_MEMORY_IN_IMMEDIAT             ->write (fifo_request.top()._immediat             );
                   in_MEMORY_IN_DATA_RA              ->write (fifo_request.top()._data_ra              );
                   in_MEMORY_IN_DATA_RB              ->write (fifo_request.top()._data_rb              );
 //                in_MEMORY_IN_WRITE_RD             ->write (fifo_request.top()._write_rd             );
                   in_MEMORY_IN_NUM_REG_RD           ->write (fifo_request.top()._num_reg_rd           );
+                  in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE [0]->write (fifo_request.top()._load_queue_ptr_write );
+                  in_MEMORY_IN_IMMEDIAT             [0]->write (fifo_request.top()._immediat             );
+                  in_MEMORY_IN_DATA_RA              [0]->write (fifo_request.top()._data_ra              );
+                  in_MEMORY_IN_DATA_RB              [0]->write (fifo_request.top()._data_rb              );
+//                in_MEMORY_IN_WRITE_RD             [0]->write (fifo_request.top()._write_rd             );
+                  in_MEMORY_IN_NUM_REG_RD           [0]->write (fifo_request.top()._num_reg_rd           );
+                }
               in_MEMORY_OUT_ACK->write((rand()%100)<percent_transaction_memory_out);
+              in_MEMORY_OUT_ACK[0]->write((rand()%100)<percent_transaction_memory_out);
               // ***** DCACHE_REQ *****
               in_DCACHE_REQ_ACK->write((rand()%100)<percent_transaction_dcache);
+              in_DCACHE_REQ_ACK[0]->write((rand()%100)<percent_transaction_dcache);
               // ***** DCACHE_RSP *****
               bool have_rsp = _cache->have_rsp ();
               in_DCACHE_RSP_VAL->write(have_rsp);
+              in_DCACHE_RSP_VAL[0]->write(have_rsp);
               if (have_rsp)
+                {
                   in_DCACHE_RSP_CONTEXT_ID->write(_cache->front()._context_id);
                   in_DCACHE_RSP_PACKET_ID ->write(_cache->front()._packet_id );
                   in_DCACHE_RSP_RDATA     ->write(_cache->front()._rdata     );
                   in_DCACHE_RSP_ERROR     ->write(_cache->front()._error     );
+                  in_DCACHE_RSP_CONTEXT_ID[0]->write(_cache->front()._context_id);
+                  in_DCACHE_RSP_PACKET_ID [0]->write(_cache->front()._packet_id );
+                  in_DCACHE_RSP_RDATA     [0]->write(_cache->front()._rdata     );
+                  in_DCACHE_RSP_ERROR     [0]->write(_cache->front()._error     );
+                }
               SC_START(0);
               LABEL("MEMORY_IN  : %d - %d",in_MEMORY_IN_VAL ->read(),out_MEMORY_IN_ACK ->read());
               if ( in_MEMORY_IN_VAL ->read() and out_MEMORY_IN_ACK ->read())
+              LABEL("MEMORY_IN  : %d - %d",in_MEMORY_IN_VAL [0]->read(),out_MEMORY_IN_ACK [0]->read());
+              if ( in_MEMORY_IN_VAL [0]->read() and out_MEMORY_IN_ACK [0]->read())
+                {
                   Tpacket_t  packet_id = in_MEMORY_IN_PACKET_ID->read();
+                  Tpacket_t  packet_id = in_MEMORY_IN_PACKET_ID[0]->read();
                   LABEL(" * Accepted MEMORY_IN  : %d",packet_id);
 …
+                }
               LABEL("MEMORY_OUT : %d - %d",out_MEMORY_OUT_VAL->read(),in_MEMORY_OUT_ACK ->read());
               if (out_MEMORY_OUT_VAL->read() and  in_MEMORY_OUT_ACK->read())
+              LABEL("MEMORY_OUT : %d - %d",out_MEMORY_OUT_VAL[0]->read(),in_MEMORY_OUT_ACK [0]->read());
+              if (out_MEMORY_OUT_VAL[0]->read() and  in_MEMORY_OUT_ACK[0]->read())
+                {
                   Tpacket_t  packet_id = out_MEMORY_OUT_PACKET_ID->read();
+                  Tpacket_t  packet_id = out_MEMORY_OUT_PACKET_ID[0]->read();
                   LABEL(" * Accepted MEMORY_OUT : %d",packet_id);
 …
                   else
+                    {
                       if (not (out_MEMORY_OUT_EXCEPTION->read() == EXCEPTION_MEMORY_LOAD_SPECULATIVE))
+                      if (not (out_MEMORY_OUT_EXCEPTION[0]->read() == EXCEPTION_MEMORY_LOAD_SPECULATIVE))
+                        {
                           nb_request_memory_out ++;
 …
+                        {
                           std::cout << "seth - have a load_speculative." << std::endl;
                           tab_request[packet_id]._write_spec_ko = (out_MEMORY_OUT_DATA_RD->read() != tab_request[packet_id]._data_wait);
+                          tab_request[packet_id]._write_spec_ko = (out_MEMORY_OUT_DATA_RD[0]->read() != tab_request[packet_id]._data_wait);
                           tab_request[packet_id]._previous_load_speculative = 1;
+                        }
 …
                   // a lot of test
                   TEST(Tpacket_t         , out_MEMORY_OUT_PACKET_ID    ->read(), tab_request[packet_id]._packet_id    );
                   TEST(Tcontext_t        , out_MEMORY_OUT_CONTEXT_ID   ->read(), tab_request[packet_id]._context_id   );
                   TEST(Tcontext_t        , out_MEMORY_OUT_FRONT_END_ID ->read(), tab_request[packet_id]._front_end_id );
                   TEST(Tcontext_t        , out_MEMORY_OUT_OOO_ENGINE_ID->read(), tab_request[packet_id]._ooo_engine_id);
 //                TEST(Toperation_t      , out_MEMORY_OUT_OPERATION    ->read(), tab_request[packet_id]._operation    );
                   TEST(Ttype_t           , out_MEMORY_OUT_TYPE         ->read(), TYPE_MEMORY                          );
+                  TEST(Tpacket_t         , out_MEMORY_OUT_PACKET_ID    [0]->read(), tab_request[packet_id]._packet_id    );
+                  TEST(Tcontext_t        , out_MEMORY_OUT_CONTEXT_ID   [0]->read(), tab_request[packet_id]._context_id   );
+                  TEST(Tcontext_t        , out_MEMORY_OUT_FRONT_END_ID [0]->read(), tab_request[packet_id]._front_end_id );
+                  TEST(Tcontext_t        , out_MEMORY_OUT_OOO_ENGINE_ID[0]->read(), tab_request[packet_id]._ooo_engine_id);
+//                TEST(Toperation_t      , out_MEMORY_OUT_OPERATION    [0]->read(), tab_request[packet_id]._operation    );
+                  TEST(Ttype_t           , out_MEMORY_OUT_TYPE         [0]->read(), TYPE_MEMORY                          );
                   if (is_operation_memory_load (tab_request[packet_id]._operation))
+                    {
                       TEST(Tgeneral_address_t, out_MEMORY_OUT_NUM_REG_RD   ->read(), tab_request[packet_id]._num_reg_rd   );
+                      TEST(Tgeneral_address_t, out_MEMORY_OUT_NUM_REG_RD   [0]->read(), tab_request[packet_id]._num_reg_rd   );
+                    }
 …
                   bool            error_alignment = (address != (address & (~ mask_memory_access(tab_request[packet_id]._operation))));
                   bool            berr            = (address >= size_memory);
                   Texception_t    exception       = out_MEMORY_OUT_EXCEPTION->read();
+                  Texception_t    exception       = out_MEMORY_OUT_EXCEPTION[0]->read();
                   if (is_operation_memory_store(tab_request[packet_id]._operation))
+                    {
                       TEST(Tcontrol_t        , out_MEMORY_OUT_WRITE_RD     ->read(), 0);
+                      TEST(Tcontrol_t        , out_MEMORY_OUT_WRITE_RD     [0]->read(), 0);
                       // store.
 …
                           if (test_result_ko)
+                            {
                               TEST(Tgeneral_data_t   , out_MEMORY_OUT_DATA_RD->read(), address);
+                              TEST(Tgeneral_data_t   , out_MEMORY_OUT_DATA_RD[0]->read(), address);
+                            }
+                    }
 …
                       bool is_load = is_operation_memory_load(tab_request[packet_id]._operation);
                       if (not (out_MEMORY_OUT_EXCEPTION->read() == EXCEPTION_MEMORY_LOAD_SPECULATIVE))
+                      if (not (out_MEMORY_OUT_EXCEPTION[0]->read() == EXCEPTION_MEMORY_LOAD_SPECULATIVE))
+                        {
                           bool test_result_ko = false;
 …
                               // IS A LOAD :D
                               TEST(Texception_t, exception, EXCEPTION_MEMORY_MISS_SPECULATION);
                               TEST(Tcontrol_t, out_MEMORY_OUT_WRITE_RD->read(), 1);
+                              TEST(Tcontrol_t, out_MEMORY_OUT_WRITE_RD[0]->read(), 1);
+                            }
                           else
 …
+                              {
                                 TEST(Texception_t, exception, EXCEPTION_MEMORY_ALIGNMENT);
                                 TEST(Tcontrol_t, out_MEMORY_OUT_WRITE_RD->read(), is_load);
+                                TEST(Tcontrol_t, out_MEMORY_OUT_WRITE_RD[0]->read(), is_load);
                                 test_result_ko = true;
+                              }
 …
+                                {
                                   TEST(Texception_t, exception, EXCEPTION_MEMORY_BUS_ERROR);
                                   TEST(Tcontrol_t  , out_MEMORY_OUT_WRITE_RD->read(), is_load);
+                                  TEST(Tcontrol_t  , out_MEMORY_OUT_WRITE_RD[0]->read(), is_load);
                                   test_result_ko = true;
+                                }
 …
+                                {
                                   TEST(Texception_t, exception, EXCEPTION_MEMORY_NONE);
                                   TEST(Tcontrol_t  , out_MEMORY_OUT_WRITE_RD->read(), is_load and not tab_request[packet_id]._previous_load_speculative);
+                                  TEST(Tcontrol_t  , out_MEMORY_OUT_WRITE_RD[0]->read(), is_load and not tab_request[packet_id]._previous_load_speculative);
+                                }
                           // In all case : test data
                           if (test_result_ko)
+                            {
                               TEST(Tgeneral_data_t   , out_MEMORY_OUT_DATA_RD->read(), address);
+                              TEST(Tgeneral_data_t   , out_MEMORY_OUT_DATA_RD[0]->read(), address);
+                            }
                           else
+                            {
                               TEST(Tgeneral_data_t   , out_MEMORY_OUT_DATA_RD->read(), tab_request[packet_id]._data_wait);
+                              TEST(Tgeneral_data_t   , out_MEMORY_OUT_DATA_RD[0]->read(), tab_request[packet_id]._data_wait);
+                            }
+                        }
                       else
+                        {
                           TEST(Tcontrol_t        , out_MEMORY_OUT_WRITE_RD     ->read(), 1);
+                          TEST(Tcontrol_t        , out_MEMORY_OUT_WRITE_RD     [0]->read(), 1);
+                        }
+                    }
+                }
               LABEL("DCACHE_REQ : %d - %d",out_DCACHE_REQ_VAL->read(),in_DCACHE_REQ_ACK ->read());
               if (out_DCACHE_REQ_VAL->read() and  in_DCACHE_REQ_ACK->read())
+              LABEL("DCACHE_REQ : %d - %d",out_DCACHE_REQ_VAL[0]->read(),in_DCACHE_REQ_ACK [0]->read());
+              if (out_DCACHE_REQ_VAL[0]->read() and  in_DCACHE_REQ_ACK[0]->read())
+                {
                   Tcontext_t        context_id;
                   Tpacket_t         packet_id ;
                   Tdcache_address_t address = out_DCACHE_REQ_ADDRESS->read();
+                  Tdcache_address_t address = out_DCACHE_REQ_ADDRESS[0]->read();
                   Tdcache_data_t    rdata;
                   Tdcache_error_t   error = 0;
                   if (_param->_have_port_dcache_context_id)
                     context_id = out_DCACHE_REQ_CONTEXT_ID->read();
+                    context_id = out_DCACHE_REQ_CONTEXT_ID[0]->read();
                   else
                     context_id = 0;
                   packet_id  = (out_DCACHE_REQ_PACKET_ID ->read())>>1;
+                  packet_id  = (out_DCACHE_REQ_PACKET_ID [0]->read())>>1;
                   LABEL(" * Accepted DCACHE_REQ : %d",packet_id);
 …
                   else
+                    {
                       rdata = _memory->access (context_id, address, out_DCACHE_REQ_TYPE->read(), out_DCACHE_REQ_WDATA->read());
+                      rdata = _memory->access (context_id, address, out_DCACHE_REQ_TYPE[0]->read(), out_DCACHE_REQ_WDATA[0]->read());
                       LABEL("   * rdata : 0x%x",rdata);
+                    }
                   // test type : send or not a respons !
                   if ((out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_SYNCHRONIZATION) or
                       (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_LOAD_8 ) or
                       (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_LOAD_16) or
                       (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_LOAD_32) or
                       (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_LOAD_64) or
                       ((error != DCACHE_ERROR_NONE) and ((out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_STORE_8 ) or
                                                          (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_STORE_16) or
                                                          (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_STORE_32) or
                                                          (out_DCACHE_REQ_TYPE->read() == DCACHE_TYPE_STORE_64) )))
+                  if ((out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_SYNCHRONIZATION) or
+                      (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_LOAD_8 ) or
+                      (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_LOAD_16) or
+                      (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_LOAD_32) or
+                      (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_LOAD_64) or
+                      ((error != DCACHE_ERROR_NONE) and ((out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_STORE_8 ) or
+                                                         (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_STORE_16) or
+                                                         (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_STORE_32) or
+                                                         (out_DCACHE_REQ_TYPE[0]->read() == DCACHE_TYPE_STORE_64) )))
+                    {
                       LABEL("     * have_dcache_rsp");
                       _cache->push (context_id,
                                     out_DCACHE_REQ_PACKET_ID ->read(),
+                                    out_DCACHE_REQ_PACKET_ID [0]->read(),
                                     rdata,
                                     error);
 …
+                }
               LABEL("DCACHE_RSP : %d - %d",in_DCACHE_RSP_VAL->read(),out_DCACHE_RSP_ACK ->read());
               if (in_DCACHE_RSP_VAL->read() and out_DCACHE_RSP_ACK->read())
+              LABEL("DCACHE_RSP : %d - %d",in_DCACHE_RSP_VAL[0]->read(),out_DCACHE_RSP_ACK [0]->read());
+              if (in_DCACHE_RSP_VAL[0]->read() and out_DCACHE_RSP_ACK[0]->read())
+                {
                   _cache->pop();
 …
   delete     in_NRESET;
+  delete     in_MEMORY_IN_VAL         ;
+  delete    out_MEMORY_IN_ACK         ;
+  delete     in_MEMORY_IN_CONTEXT_ID  ;
+  delete     in_MEMORY_IN_FRONT_END_ID  ;
+  delete     in_MEMORY_IN_OOO_ENGINE_ID  ;
+  delete     in_MEMORY_IN_PACKET_ID   ;
+  delete     in_MEMORY_IN_OPERATION   ;
+  delete     in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
+  delete     in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
+  delete     in_MEMORY_IN_HAS_IMMEDIAT;
+  delete     in_MEMORY_IN_IMMEDIAT    ;
+  delete     in_MEMORY_IN_DATA_RA     ;
+  delete     in_MEMORY_IN_DATA_RB     ;
+  delete     in_MEMORY_IN_DATA_RC     ;
+  delete     in_MEMORY_IN_WRITE_RD    ;
+  delete     in_MEMORY_IN_NUM_REG_RD  ;
+  delete     in_MEMORY_IN_WRITE_RE    ;
+  delete     in_MEMORY_IN_NUM_REG_RE  ;
+  delete    out_MEMORY_OUT_VAL       ;
+  delete     in_MEMORY_OUT_ACK       ;
+  delete    out_MEMORY_OUT_CONTEXT_ID;
+  delete    out_MEMORY_OUT_FRONT_END_ID;
+  delete    out_MEMORY_OUT_OOO_ENGINE_ID;
+  delete    out_MEMORY_OUT_PACKET_ID ;
+//   delete    out_MEMORY_OUT_OPERATION ;
+  delete    out_MEMORY_OUT_TYPE      ;
+  delete    out_MEMORY_OUT_WRITE_RD  ;
+  delete    out_MEMORY_OUT_NUM_REG_RD;
+  delete    out_MEMORY_OUT_DATA_RD   ;
+  delete    out_MEMORY_OUT_WRITE_RE  ;
+  delete    out_MEMORY_OUT_NUM_REG_RE;
+  delete    out_MEMORY_OUT_DATA_RE   ;
+  delete    out_MEMORY_OUT_EXCEPTION ;
+  delete    out_MEMORY_OUT_NO_SEQUENCE;
+  delete    out_MEMORY_OUT_ADDRESS   ;
+  delete    out_DCACHE_REQ_VAL       ;
+  delete     in_DCACHE_REQ_ACK       ;
+  delete    out_DCACHE_REQ_CONTEXT_ID;
+  delete    out_DCACHE_REQ_PACKET_ID ;
+  delete    out_DCACHE_REQ_ADDRESS   ;
+  delete    out_DCACHE_REQ_TYPE      ;
+  delete    out_DCACHE_REQ_WDATA     ;
+  delete     in_DCACHE_RSP_VAL       ;
+  delete    out_DCACHE_RSP_ACK       ;
+  delete     in_DCACHE_RSP_CONTEXT_ID;
+  delete     in_DCACHE_RSP_PACKET_ID ;
+  delete     in_DCACHE_RSP_RDATA     ;
+  delete     in_DCACHE_RSP_ERROR     ;
+    {
+      delete [] out_BYPASS_MEMORY_VAL       ;
+      delete [] out_BYPASS_MEMORY_OOO_ENGINE_ID;
+      delete [] out_BYPASS_MEMORY_NUM_REG   ;
+      delete [] out_BYPASS_MEMORY_DATA      ;
+    }
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_VAL                  ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_IN_ACK                  ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_CONTEXT_ID           ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_FRONT_END_ID         ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_OOO_ENGINE_ID        ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_PACKET_ID            ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_OPERATION            ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_TYPE                 ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_HAS_IMMEDIAT         ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_IMMEDIAT             ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_DATA_RA              ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_DATA_RB              ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_DATA_RC              ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_WRITE_RD             ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_NUM_REG_RD           ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_WRITE_RE             ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_IN_NUM_REG_RE           ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_VAL          ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL( in_MEMORY_OUT_ACK          ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_CONTEXT_ID   ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_FRONT_END_ID ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_OOO_ENGINE_ID,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_PACKET_ID    ,_param->_nb_inst_memory);
+//DELETE1_SC_SIGNAL(out_MEMORY_OUT_OPERATION    ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_TYPE         ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_WRITE_RD     ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_NUM_REG_RD   ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_DATA_RD      ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_WRITE_RE     ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_NUM_REG_RE   ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_DATA_RE      ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_EXCEPTION    ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_NO_SEQUENCE  ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_MEMORY_OUT_ADDRESS      ,_param->_nb_inst_memory);
+  DELETE1_SC_SIGNAL(out_DCACHE_REQ_VAL        ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL( in_DCACHE_REQ_ACK        ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_DCACHE_REQ_CONTEXT_ID ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_DCACHE_REQ_PACKET_ID  ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_DCACHE_REQ_ADDRESS    ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_DCACHE_REQ_TYPE       ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_DCACHE_REQ_WDATA      ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL( in_DCACHE_RSP_VAL        ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_DCACHE_RSP_ACK        ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL( in_DCACHE_RSP_CONTEXT_ID ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL( in_DCACHE_RSP_PACKET_ID  ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL( in_DCACHE_RSP_RDATA      ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL( in_DCACHE_RSP_ERROR      ,_param->_nb_cache_port);
+  DELETE1_SC_SIGNAL(out_BYPASS_MEMORY_VAL           ,_param->_nb_bypass_memory);
+  DELETE1_SC_SIGNAL(out_BYPASS_MEMORY_OOO_ENGINE_ID ,_param->_nb_bypass_memory);
+  DELETE1_SC_SIGNAL(out_BYPASS_MEMORY_NUM_REG       ,_param->_nb_bypass_memory);
+  DELETE1_SC_SIGNAL(out_BYPASS_MEMORY_DATA          ,_param->_nb_bypass_memory);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Load_store_unit.h

-              r82
+              r88
     // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_VAL         ;
   public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_IN_ACK         ;
   public    : SC_IN (Tcontext_t        )    *  in_MEMORY_IN_CONTEXT_ID  ;
   public    : SC_IN (Tcontext_t        )    *  in_MEMORY_IN_FRONT_END_ID;
   public    : SC_IN (Tcontext_t        )    *  in_MEMORY_IN_OOO_ENGINE_ID;
   public    : SC_IN (Tpacket_t         )    *  in_MEMORY_IN_PACKET_ID   ;
   public    : SC_IN (Toperation_t      )    *  in_MEMORY_IN_OPERATION   ;
   public    : SC_IN (Ttype_t           )    *  in_MEMORY_IN_TYPE        ;
   public    : SC_IN (Tlsq_ptr_t        )    *  in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
   public    : SC_IN (Tlsq_ptr_t        )    *  in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
   public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_HAS_IMMEDIAT;
   public    : SC_IN (Tgeneral_data_t   )    *  in_MEMORY_IN_IMMEDIAT    ; // memory address
   public    : SC_IN (Tgeneral_data_t   )    *  in_MEMORY_IN_DATA_RA     ; // memory address
   public    : SC_IN (Tgeneral_data_t   )    *  in_MEMORY_IN_DATA_RB     ; // data        (store)
   public    : SC_IN (Tspecial_data_t   )    *  in_MEMORY_IN_DATA_RC     ;
   public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_WRITE_RD    ; // = (operation==load)
   public    : SC_IN (Tgeneral_address_t)    *  in_MEMORY_IN_NUM_REG_RD  ; // destination (load)
   public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_IN_WRITE_RE    ;
   public    : SC_IN (Tspecial_address_t)    *  in_MEMORY_IN_NUM_REG_RE  ;
+  public    : SC_IN (Tcontrol_t        )   **  in_MEMORY_IN_VAL                  ;//[nb_inst_memory]
+  public    : SC_OUT(Tcontrol_t        )   ** out_MEMORY_IN_ACK                  ;//[nb_inst_memory]
+  public    : SC_IN (Tcontext_t        )   **  in_MEMORY_IN_CONTEXT_ID           ;//[nb_inst_memory]
+  public    : SC_IN (Tcontext_t        )   **  in_MEMORY_IN_FRONT_END_ID         ;//[nb_inst_memory]
+  public    : SC_IN (Tcontext_t        )   **  in_MEMORY_IN_OOO_ENGINE_ID        ;//[nb_inst_memory]
+  public    : SC_IN (Tpacket_t         )   **  in_MEMORY_IN_PACKET_ID            ;//[nb_inst_memory]
+  public    : SC_IN (Toperation_t      )   **  in_MEMORY_IN_OPERATION            ;//[nb_inst_memory]
+  public    : SC_IN (Ttype_t           )   **  in_MEMORY_IN_TYPE                 ;//[nb_inst_memory]
+  public    : SC_IN (Tlsq_ptr_t        )   **  in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;//[nb_inst_memory]
+  public    : SC_IN (Tlsq_ptr_t        )   **  in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;//[nb_inst_memory]
+  public    : SC_IN (Tcontrol_t        )   **  in_MEMORY_IN_HAS_IMMEDIAT         ;//[nb_inst_memory]
+  public    : SC_IN (Tgeneral_data_t   )   **  in_MEMORY_IN_IMMEDIAT             ;//[nb_inst_memory] // memory address
+  public    : SC_IN (Tgeneral_data_t   )   **  in_MEMORY_IN_DATA_RA              ;//[nb_inst_memory] // memory address
+  public    : SC_IN (Tgeneral_data_t   )   **  in_MEMORY_IN_DATA_RB              ;//[nb_inst_memory] // data        (store)
+  public    : SC_IN (Tspecial_data_t   )   **  in_MEMORY_IN_DATA_RC              ;//[nb_inst_memory]
+  public    : SC_IN (Tcontrol_t        )   **  in_MEMORY_IN_WRITE_RD             ;//[nb_inst_memory] // = (operation==load)
+  public    : SC_IN (Tgeneral_address_t)   **  in_MEMORY_IN_NUM_REG_RD           ;//[nb_inst_memory] // destination (load)
+  public    : SC_IN (Tcontrol_t        )   **  in_MEMORY_IN_WRITE_RE             ;//[nb_inst_memory]
+  public    : SC_IN (Tspecial_address_t)   **  in_MEMORY_IN_NUM_REG_RE           ;//[nb_inst_memory]
     // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_VAL       ;
   public    : SC_IN (Tcontrol_t        )    *  in_MEMORY_OUT_ACK       ;
   public    : SC_OUT(Tcontext_t        )    * out_MEMORY_OUT_CONTEXT_ID;
   public    : SC_OUT(Tcontext_t        )    * out_MEMORY_OUT_FRONT_END_ID;
   public    : SC_OUT(Tcontext_t        )    * out_MEMORY_OUT_OOO_ENGINE_ID;
   public    : SC_OUT(Tpacket_t         )    * out_MEMORY_OUT_PACKET_ID ;
 //public    : SC_OUT(Toperation_t      )    * out_MEMORY_OUT_OPERATION ;
   public    : SC_OUT(Ttype_t           )    * out_MEMORY_OUT_TYPE      ;
   public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_WRITE_RD  ; // = (operation==load)
   public    : SC_OUT(Tgeneral_address_t)    * out_MEMORY_OUT_NUM_REG_RD; // destination (load)
   public    : SC_OUT(Tgeneral_data_t   )    * out_MEMORY_OUT_DATA_RD   ; // data        (load)
   public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_WRITE_RE  ;
   public    : SC_OUT(Tspecial_address_t)    * out_MEMORY_OUT_NUM_REG_RE;
   public    : SC_OUT(Tspecial_data_t   )    * out_MEMORY_OUT_DATA_RE   ;
   public    : SC_OUT(Texception_t      )    * out_MEMORY_OUT_EXCEPTION ;
   public    : SC_OUT(Tcontrol_t        )    * out_MEMORY_OUT_NO_SEQUENCE;
   public    : SC_OUT(Tgeneral_data_t   )    * out_MEMORY_OUT_ADDRESS   ;
+  public    : SC_OUT(Tcontrol_t        )   ** out_MEMORY_OUT_VAL                 ;//[nb_inst_memory]
+  public    : SC_IN (Tcontrol_t        )   **  in_MEMORY_OUT_ACK                 ;//[nb_inst_memory]
+  public    : SC_OUT(Tcontext_t        )   ** out_MEMORY_OUT_CONTEXT_ID          ;//[nb_inst_memory]
+  public    : SC_OUT(Tcontext_t        )   ** out_MEMORY_OUT_FRONT_END_ID        ;//[nb_inst_memory]
+  public    : SC_OUT(Tcontext_t        )   ** out_MEMORY_OUT_OOO_ENGINE_ID       ;//[nb_inst_memory]
+  public    : SC_OUT(Tpacket_t         )   ** out_MEMORY_OUT_PACKET_ID           ;//[nb_inst_memory]
+//public    : SC_OUT(Toperation_t      )   ** out_MEMORY_OUT_OPERATION           ;//[nb_inst_memory]
+  public    : SC_OUT(Ttype_t           )   ** out_MEMORY_OUT_TYPE                ;//[nb_inst_memory]
+  public    : SC_OUT(Tcontrol_t        )   ** out_MEMORY_OUT_WRITE_RD            ;//[nb_inst_memory] // = (operation==load)
+  public    : SC_OUT(Tgeneral_address_t)   ** out_MEMORY_OUT_NUM_REG_RD          ;//[nb_inst_memory] // destination (load)
+  public    : SC_OUT(Tgeneral_data_t   )   ** out_MEMORY_OUT_DATA_RD             ;//[nb_inst_memory] // data        (load)
+  public    : SC_OUT(Tcontrol_t        )   ** out_MEMORY_OUT_WRITE_RE            ;//[nb_inst_memory]
+  public    : SC_OUT(Tspecial_address_t)   ** out_MEMORY_OUT_NUM_REG_RE          ;//[nb_inst_memory]
+  public    : SC_OUT(Tspecial_data_t   )   ** out_MEMORY_OUT_DATA_RE             ;//[nb_inst_memory]
+  public    : SC_OUT(Texception_t      )   ** out_MEMORY_OUT_EXCEPTION           ;//[nb_inst_memory]
+  public    : SC_OUT(Tcontrol_t        )   ** out_MEMORY_OUT_NO_SEQUENCE         ;//[nb_inst_memory]
+  public    : SC_OUT(Tgeneral_data_t   )   ** out_MEMORY_OUT_ADDRESS             ;//[nb_inst_memory]
     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t        )    * out_DCACHE_REQ_VAL       ;
   public    : SC_IN (Tcontrol_t        )    *  in_DCACHE_REQ_ACK       ;
   public    : SC_OUT(Tcontext_t        )    * out_DCACHE_REQ_CONTEXT_ID;
   public    : SC_OUT(Tpacket_t         )    * out_DCACHE_REQ_PACKET_ID ;
   public    : SC_OUT(Tdcache_address_t )    * out_DCACHE_REQ_ADDRESS   ;
   public    : SC_OUT(Tdcache_type_t    )    * out_DCACHE_REQ_TYPE      ;
   public    : SC_OUT(Tdcache_data_t    )    * out_DCACHE_REQ_WDATA     ;
+  public    : SC_OUT(Tcontrol_t        )   ** out_DCACHE_REQ_VAL                 ;//[nb_cache_port]
+  public    : SC_IN (Tcontrol_t        )   **  in_DCACHE_REQ_ACK                 ;//[nb_cache_port]
+  public    : SC_OUT(Tcontext_t        )   ** out_DCACHE_REQ_CONTEXT_ID          ;//[nb_cache_port]
+  public    : SC_OUT(Tpacket_t         )   ** out_DCACHE_REQ_PACKET_ID           ;//[nb_cache_port]
+  public    : SC_OUT(Tdcache_address_t )   ** out_DCACHE_REQ_ADDRESS             ;//[nb_cache_port]
+  public    : SC_OUT(Tdcache_type_t    )   ** out_DCACHE_REQ_TYPE                ;//[nb_cache_port]
+  public    : SC_OUT(Tdcache_data_t    )   ** out_DCACHE_REQ_WDATA               ;//[nb_cache_port]
     // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )    *  in_DCACHE_RSP_VAL       ;
   public    : SC_OUT(Tcontrol_t        )    * out_DCACHE_RSP_ACK       ;
   public    : SC_IN (Tcontext_t        )    *  in_DCACHE_RSP_CONTEXT_ID;
   public    : SC_IN (Tpacket_t         )    *  in_DCACHE_RSP_PACKET_ID ;
   public    : SC_IN (Tdcache_data_t    )    *  in_DCACHE_RSP_RDATA     ;
   public    : SC_IN (Tdcache_error_t   )    *  in_DCACHE_RSP_ERROR     ;
+  public    : SC_IN (Tcontrol_t        )   **  in_DCACHE_RSP_VAL                 ;//[nb_cache_port]
+  public    : SC_OUT(Tcontrol_t        )   ** out_DCACHE_RSP_ACK                 ;//[nb_cache_port]
+  public    : SC_IN (Tcontext_t        )   **  in_DCACHE_RSP_CONTEXT_ID          ;//[nb_cache_port]
+  public    : SC_IN (Tpacket_t         )   **  in_DCACHE_RSP_PACKET_ID           ;//[nb_cache_port]
+  public    : SC_IN (Tdcache_data_t    )   **  in_DCACHE_RSP_RDATA               ;//[nb_cache_port]
+  public    : SC_IN (Tdcache_error_t   )   **  in_DCACHE_RSP_ERROR               ;//[nb_cache_port]
     // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t        )   ** out_BYPASS_MEMORY_VAL       ;
   public    : SC_OUT(Tcontext_t        )   ** out_BYPASS_MEMORY_OOO_ENGINE_ID;
   public    : SC_OUT(Tgeneral_address_t)   ** out_BYPASS_MEMORY_NUM_REG   ;
   public    : SC_OUT(Tgeneral_data_t   )   ** out_BYPASS_MEMORY_DATA      ;
+  public    : SC_OUT(Tcontrol_t        )   ** out_BYPASS_MEMORY_VAL          ; //[nb_bypass_memory]
+  public    : SC_OUT(Tcontext_t        )   ** out_BYPASS_MEMORY_OOO_ENGINE_ID; //[nb_bypass_memory]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_BYPASS_MEMORY_NUM_REG      ; //[nb_bypass_memory]
+  public    : SC_OUT(Tgeneral_data_t   )   ** out_BYPASS_MEMORY_DATA         ; //[nb_bypass_memory]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // signal
   public    : Tlsq_ptr_t                      internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ ;
+  private   : Tcontrol_t                      internal_MEMORY_IN_ACK;
+  private   : Tcontrol_t                      internal_MEMORY_OUT_VAL;
+  private   : Tcontrol_t                      internal_MEMORY_IN_ACK          ;
+  private   : uint32_t                        internal_MEMORY_IN_PORT         ;
+  private   : Tcontrol_t                      internal_MEMORY_OUT_VAL         ;
   private   : Tselect_queue_t                 internal_MEMORY_OUT_SELECT_QUEUE;
   public    : Tlsq_ptr_t                      internal_MEMORY_OUT_PTR;
   private   : Tcontrol_t                      internal_DCACHE_RSP_ACK;
   private   : Tcontrol_t                      internal_DCACHE_REQ_VAL;
+  private   : Tlsq_ptr_t                      internal_MEMORY_OUT_PTR         ;
+  private   : Tcontrol_t                      internal_DCACHE_RSP_ACK         ;
+  private   : Tcontrol_t                      internal_DCACHE_REQ_VAL         ;
   private   : Tselect_queue_t                 internal_DCACHE_REQ_SELECT_QUEUE;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
+  public : const uint32_t            _size_store_queue             ;
+  public : const uint32_t            _size_load_queue              ;
+  public : const uint32_t            _size_speculative_access_queue;
+  public : const uint32_t            _nb_port_check                ;
+  public : const Tspeculative_load_t _speculative_load             ;
+  public : const uint32_t            _nb_bypass_memory             ;
+//public : const uint32_t            _nb_cache_port                ;
+  public : const uint32_t            _nb_context                   ;
+  public : const uint32_t            _nb_front_end                 ;
+  public : const uint32_t            _nb_ooo_engine                ;
+  public : const uint32_t            _nb_packet                    ;
+  public : const uint32_t            _size_general_data            ;
+  public : const uint32_t            _size_special_data            ;
+  public : const uint32_t            _nb_general_register          ;
+  public : const uint32_t            _nb_special_register          ;
+  public : uint32_t            _size_store_queue             ;
+  public : uint32_t            _size_load_queue              ;
+  public : uint32_t            _size_speculative_access_queue;
+  public : uint32_t            _nb_port_check                ;
+  public : Tspeculative_load_t _speculative_load             ;
+  public : uint32_t            _nb_bypass_memory             ;
+  public : uint32_t            _nb_cache_port                ;
+  public : uint32_t            _nb_inst_memory               ;
+  public : uint32_t            _nb_context                   ;
+  public : uint32_t            _nb_front_end                 ;
+  public : uint32_t            _nb_ooo_engine                ;
+  public : uint32_t            _nb_packet                    ;
+//public : uint32_t            _size_general_data            ;
+//public : uint32_t            _size_special_data            ;
+  public : uint32_t            _nb_general_register          ;
+  public : uint32_t            _nb_special_register          ;
   public : const uint32_t            _size_address_store_queue             ;
   public : const uint32_t            _size_address_load_queue              ;
   public : const uint32_t            _size_address_speculative_access_queue;
   public : const uint32_t            _size_context_id                      ;
   public : const uint32_t            _size_front_end_id                    ;
   public : const uint32_t            _size_ooo_engine_id                   ;
   public : const uint32_t            _size_packet_id                       ;
   public : const uint32_t            _size_general_register                ;
   public : const uint32_t            _size_special_register                ;
   public : const uint32_t            _size_dcache_context_id               ;
   public : const uint32_t            _size_dcache_packet_id                ;
+//public : uint32_t            _size_address_store_queue             ;
+//public : uint32_t            _size_address_load_queue              ;
+  public : uint32_t            _size_speculative_access_queue_ptr    ;
+//public : uint32_t            _size_context_id                      ;
+//public : uint32_t            _size_front_end_id                    ;
+//public : uint32_t            _size_ooo_engine_id                   ;
+//public : uint32_t            _size_packet_id                       ;
+//public : uint32_t            _size_general_register                ;
+//public : uint32_t            _size_special_register                ;
+  public : uint32_t            _size_dcache_context_id               ;
+  public : uint32_t            _size_dcache_packet_id                ;
   public : const bool                _have_port_context_id                 ;
   public : const bool                _have_port_front_end_id               ;
   public : const bool                _have_port_ooo_engine_id              ;
   public : const bool                _have_port_packet_id                  ;
   public : const bool                _have_port_dcache_context_id          ;
   public : const bool                _have_port_load_queue_ptr             ;
+//public : bool                _have_port_context_id                 ;
+//public : bool                _have_port_front_end_id               ;
+//public : bool                _have_port_ooo_engine_id              ;
+//public : bool                _have_port_packet_id                  ;
+  public : bool                _have_port_dcache_context_id          ;
+//public : bool                _have_port_load_queue_ptr             ;
   public : const Tdcache_address_t   _mask_address_lsb                     ;
   public : const Tdcache_address_t   _mask_address_msb                     ;
+  public : Tdcache_address_t   _mask_address_lsb                     ;
+  public : Tdcache_address_t   _mask_address_msb                     ;
     //-----[ methods ]-----------------------------------------------------------
 …
                         Tspeculative_load_t speculative_load       ,
                         uint32_t            nb_bypass_memory       ,
+                        uint32_t            nb_cache_port          ,
+                        uint32_t            nb_inst_memory         ,
                         uint32_t            nb_context             ,
                         uint32_t            nb_front_end           ,
 …
                         uint32_t            size_special_data      ,
                         uint32_t            nb_general_register    ,
+                        uint32_t            nb_special_register    );
+                        uint32_t            nb_special_register    ,
+                        bool                is_toplevel=false);
+  public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public : void            copy      (void);
   public : Parameters_test msg_error (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit.cpp

-              r82
+              r88
     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
+#if DEBUG_Load_store_unit == true
+    log_printf(INFO,Load_store_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
 #ifdef SYSTEMC
     log_printf(INFO,Load_store_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Load_store_unit,FUNCTION,"Allocation of statistics");
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Load_store_unit,FUNCTION,"Allocation of statistics");
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,Load_store_unit,FUNCTION,"Generate the vhdl");
+    vhdl();
+#endif
+#ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,Load_store_unit,FUNCTION,"Generate the vhdl");
+        vhdl();
+      }
+#endif
+#ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // Function pointer
 …
     internal_DCACHE_RSP_ACK = 1;
+    PORT_WRITE(out_DCACHE_RSP_ACK, 1);
+    PORT_WRITE(out_DCACHE_RSP_ACK [0], internal_DCACHE_RSP_ACK);
+    for (uint32_t i=1; i<_param->_nb_cache_port; ++i)
+      {
+        PORT_WRITE(out_DCACHE_RSP_ACK [i], 0);
+        PORT_WRITE(out_DCACHE_REQ_VAL [i], 0);
+      }
+    for (uint32_t i=1; i<_param->_nb_inst_memory; i++)
+      {
+        PORT_WRITE(out_MEMORY_OUT_VAL [i], 0);
+      }
     log_printf(INFO,Load_store_unit,FUNCTION,"Method - transition");
 …
     dont_initialize ();
     sensitive_neg << *(in_CLOCK);
+    sensitive     << *(in_MEMORY_IN_OPERATION);
+#ifdef SYSTEMCASS_SPECIFIC
+    // List dependency information
+    (*(out_MEMORY_IN_ACK)) (*(in_MEMORY_IN_OPERATION));
+    for (uint32_t i=0; i<_param->_nb_inst_memory; i++)
+      sensitive << (*(in_MEMORY_IN_VAL       [i]))
+                << (*(in_MEMORY_IN_OPERATION [i]));
+#ifdef SYSTEMCASS_SPECIFIC
+    // List dependency information
+    for (uint32_t i=0; i<_param->_nb_inst_memory; i++)
+//       for (uint32_t x=0; x<_param->_nb_inst_memory; x++)
+        {
+          (*(out_MEMORY_IN_ACK [i])) (*(in_MEMORY_IN_VAL       [i]));
+          (*(out_MEMORY_IN_ACK [i])) (*(in_MEMORY_IN_OPERATION [i]));
+        }
 #endif
 …
     // List dependency information
 #endif
+      }
 #endif
     log_printf(FUNC,Load_store_unit,FUNCTION,"End");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Load_store_unit,FUNCTION,"Generate Statistics file");
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Load_store_unit,FUNCTION,"Generate Statistics file");
+        delete _stat;
+      }
 #endif

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

-              r82
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Load_store_unit.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       Interface * interface = _interfaces->set_interface(""
 …
                                                          ,IN
                                                          ,SOUTH,
                                                          "Generalist interface"
+                                                         _("Generalist interface")
 #endif
                                                          );
 …
       in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
+    }
+    // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      Interface_fifo * interface = _interfaces->set_interface("memory_in"
+#ifdef POSITION
+                                                              ,IN
+                                                              ,WEST
+                                                              ,"Instruction from Reservations station"
+#endif
+                                                              );
+      ALLOC1_INTERFACE("memory_in",IN,WEST,_("Instruction from Reservations station"),_param->_nb_inst_memory);
+   in_MEMORY_IN_VAL                   = interface->set_signal_valack_in        (VAL);
+  out_MEMORY_IN_ACK                   = interface->set_signal_valack_out       (ACK);
+  if (_param->_have_port_context_id)
+   in_MEMORY_IN_CONTEXT_ID            = interface->set_signal_in  <Tcontext_t        > ("context_id"   ,_param->_size_context_id       );
+  if (_param->_have_port_front_end_id)
+   in_MEMORY_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_MEMORY_IN_OOO_ENGINE_ID         = interface->set_signal_in  <Tcontext_t        > ("ooo_engine_id",_param->_size_ooo_engine_id    );
+  if (_param->_have_port_packet_id)
+   in_MEMORY_IN_PACKET_ID             = interface->set_signal_in  <Tpacket_t         > ("packet_id"    ,_param->_size_packet_id       );
+   in_MEMORY_IN_OPERATION             = interface->set_signal_in  <Toperation_t      > ("operation"   ,_param->_size_operation        );
+   in_MEMORY_IN_TYPE                  = interface->set_signal_in  <Ttype_t           > ("type"        ,_param->_size_type             );
+   in_MEMORY_IN_STORE_QUEUE_PTR_WRITE = interface->set_signal_in  <Tlsq_ptr_t        > ("store_queue_ptr_write" ,_param->_size_address_store_queue+1); // +1 cf load_queue usage
+   if (_param->_have_port_load_queue_ptr)
+   in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE  = interface->set_signal_in  <Tlsq_ptr_t        > ("load_queue_ptr_write"  ,_param->_size_address_load_queue );
+   in_MEMORY_IN_HAS_IMMEDIAT          = interface->set_signal_in  <Tcontrol_t        > ("has_immediat",1                              );
+   in_MEMORY_IN_IMMEDIAT              = interface->set_signal_in  <Tgeneral_data_t   > ("immediat"    ,_param->_size_general_data     );
+   in_MEMORY_IN_DATA_RA               = interface->set_signal_in  <Tgeneral_data_t   > ("data_ra"     ,_param->_size_general_data     );
+   in_MEMORY_IN_DATA_RB               = interface->set_signal_in  <Tgeneral_data_t   > ("data_rb"     ,_param->_size_general_data     );
+   in_MEMORY_IN_DATA_RC               = interface->set_signal_in  <Tspecial_data_t   > ("data_rc"     ,_param->_size_special_data     );
+   in_MEMORY_IN_WRITE_RD              = interface->set_signal_in  <Tcontrol_t        > ("write_rd"    ,1                              );
+   in_MEMORY_IN_NUM_REG_RD            = interface->set_signal_in  <Tgeneral_address_t> ("num_reg_rd"  ,1                              );
+   in_MEMORY_IN_WRITE_RE              = interface->set_signal_in  <Tcontrol_t        > ("write_re"    ,1                              );
+   in_MEMORY_IN_NUM_REG_RE            = interface->set_signal_in  <Tspecial_address_t> ("num_reg_re"  ,1                              );
+      ALLOC1_VALACK_IN ( in_MEMORY_IN_VAL                  ,VAL);
+      ALLOC1_VALACK_OUT(out_MEMORY_IN_ACK                  ,ACK);
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_CONTEXT_ID           ,"context_id"           ,Tcontext_t        ,_param->_size_context_id           );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id         );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id        );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr              );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation            );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type                 );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr      );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr       );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                                  );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data         );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_DATA_RA              ,"data_ra"              ,Tgeneral_data_t   ,_param->_size_general_data         );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_DATA_RB              ,"data_rb"              ,Tgeneral_data_t   ,_param->_size_general_data         );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_DATA_RC              ,"data_rc"              ,Tspecial_data_t   ,_param->_size_special_data         );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_WRITE_RD             ,"write_rd"             ,Tcontrol_t        ,1                                  );
+      ALLOC1_SIGNAL_IN ( in_MEMORY_IN_NUM_REG_RD           ,"num_reg_rd"           ,Tgeneral_address_t,1                                  );
+      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,1                                  );
+    }
     // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      Interface_fifo * interface = _interfaces->set_interface("memory_out"
+#ifdef POSITION
+                                                              ,OUT
+                                                              ,EAST
+                                                              ,"Instruction to write queue"
+#endif
+                                                              );
+      ALLOC1_INTERFACE("memory_out",OUT,EAST,_("Instruction to write queue"),_param->_nb_inst_memory);
+      out_MEMORY_OUT_VAL           = interface->set_signal_valack_out(VAL);
+       in_MEMORY_OUT_ACK           = interface->set_signal_valack_in (ACK);
+      if (_param->_have_port_context_id)
+      out_MEMORY_OUT_CONTEXT_ID    = interface->set_signal_out <Tcontext_t        > ("context_id"    ,_param->_size_context_id       );
+      if (_param->_have_port_front_end_id)
+      out_MEMORY_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_MEMORY_OUT_OOO_ENGINE_ID = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id" ,_param->_size_ooo_engine_id    );
+      if (_param->_have_port_packet_id)
+      out_MEMORY_OUT_PACKET_ID     = interface->set_signal_out <Tpacket_t         > ("packet_id"     ,_param->_size_packet_id        );
+//    out_MEMORY_OUT_OPERATION     = interface->set_signal_out <Toperation_t      > ("operation"     ,_param->_size_operation        );
+      out_MEMORY_OUT_TYPE          = interface->set_signal_out <Ttype_t           > ("type"          ,_param->_size_type             );
+      out_MEMORY_OUT_WRITE_RD      = interface->set_signal_out <Tcontrol_t        > ("write_rd"      ,1                              );
+      out_MEMORY_OUT_NUM_REG_RD    = interface->set_signal_out <Tgeneral_address_t> ("num_reg_rd"    ,_param->_size_general_register );
+      out_MEMORY_OUT_DATA_RD       = interface->set_signal_out <Tgeneral_data_t   > ("data_rd"       ,_param->_size_general_data     );
+      out_MEMORY_OUT_WRITE_RE      = interface->set_signal_out <Tcontrol_t        > ("write_re"      ,1                              );
+      out_MEMORY_OUT_NUM_REG_RE    = interface->set_signal_out <Tspecial_address_t> ("num_reg_re"    ,_param->_size_general_register );
+      out_MEMORY_OUT_DATA_RE       = interface->set_signal_out <Tspecial_data_t   > ("data_re"       ,_param->_size_general_data     );
+      out_MEMORY_OUT_EXCEPTION     = interface->set_signal_out <Texception_t      > ("exception"     ,_param->_size_exception        );
+      out_MEMORY_OUT_NO_SEQUENCE   = interface->set_signal_out <Tcontrol_t        > ("no_sequence"   ,1                              );
+      out_MEMORY_OUT_ADDRESS       = interface->set_signal_out <Tgeneral_data_t   > ("address"       ,_param->_size_general_data     );
+      ALLOC1_VALACK_OUT(out_MEMORY_OUT_VAL          ,VAL);
+      ALLOC1_VALACK_IN ( in_MEMORY_OUT_ACK          ,ACK);
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_CONTEXT_ID   ,"context_id"    ,Tcontext_t        ,_param->_size_context_id       );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_FRONT_END_ID ,"front_end_id"  ,Tcontext_t        ,_param->_size_front_end_id     );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_OOO_ENGINE_ID,"ooo_engine_id" ,Tcontext_t        ,_param->_size_ooo_engine_id    );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_PACKET_ID    ,"packet_id"     ,Tpacket_t         ,_param->_size_rob_ptr          );
+//    ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_OPERATION    ,"operation"     ,Toperation_t      ,_param->_size_operation        );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_TYPE         ,"type"          ,Ttype_t           ,_param->_size_type             );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_WRITE_RD     ,"write_rd"      ,Tcontrol_t        ,1                              );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_NUM_REG_RD   ,"num_reg_rd"    ,Tgeneral_address_t,_param->_size_general_register );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_DATA_RD      ,"data_rd"       ,Tgeneral_data_t   ,_param->_size_general_data     );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_WRITE_RE     ,"write_re"      ,Tcontrol_t        ,1                              );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_NUM_REG_RE   ,"num_reg_re"    ,Tspecial_address_t,_param->_size_general_register );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_DATA_RE      ,"data_re"       ,Tspecial_data_t   ,_param->_size_general_data     );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_EXCEPTION    ,"exception"     ,Texception_t      ,_param->_size_exception        );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_NO_SEQUENCE  ,"no_sequence"   ,Tcontrol_t        ,1                              );
+      ALLOC1_SIGNAL_OUT(out_MEMORY_OUT_ADDRESS      ,"address"       ,Tgeneral_data_t   ,_param->_size_general_data     );
+    }
     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      Interface_fifo * interface = _interfaces->set_interface("dcache_req"
+#ifdef POSITION
+                                                              ,OUT
+                                                              ,NORTH
+                                                              ,"Request port to dcache"
+#endif
+                                                              );
+      ALLOC1_INTERFACE("dcache_req",OUT,NORTH,_("Request port to dcache"),_param->_nb_cache_port);
+      out_DCACHE_REQ_VAL        = interface->set_signal_valack_out(VAL);
+       in_DCACHE_REQ_ACK        = interface->set_signal_valack_in (ACK);
+       if (_param->_have_port_dcache_context_id)
+      out_DCACHE_REQ_CONTEXT_ID = interface->set_signal_out <Tcontext_t        > ("context_id",_param->_size_dcache_context_id  );
+      out_DCACHE_REQ_PACKET_ID  = interface->set_signal_out <Tpacket_t         > ("packet_id" ,_param->_size_dcache_packet_id   );
+      out_DCACHE_REQ_ADDRESS    = interface->set_signal_out <Tdcache_address_t > ("address"   ,_param->_size_general_data);
+      out_DCACHE_REQ_TYPE       = interface->set_signal_out <Tdcache_type_t    > ("type"      ,_param->_size_dcache_type );
+      out_DCACHE_REQ_WDATA      = interface->set_signal_out <Tdcache_data_t    > ("wdata"     ,_param->_size_general_data);
+      ALLOC1_VALACK_OUT(out_DCACHE_REQ_VAL        ,VAL);
+      ALLOC1_VALACK_IN ( in_DCACHE_REQ_ACK        ,ACK);
+      ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_CONTEXT_ID ,"context_id",Tcontext_t       ,_param->_size_dcache_context_id  );
+      ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_PACKET_ID  ,"packet_id" ,Tpacket_t        ,_param->_size_dcache_packet_id   );
+      ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_ADDRESS    ,"address"   ,Tdcache_address_t,_param->_size_general_data);
+      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);
+    }
+    // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      Interface_fifo * interface = _interfaces->set_interface("dcache_rsp"
+#ifdef POSITION
+                                                              ,IN
+                                                              ,NORTH
+                                                              ,"Respons port from dcache"
+#endif
+                                                              );
+      ALLOC1_INTERFACE("dcache_rsp",IN,NORTH,_("Respons port from dcache"),_param->_nb_cache_port);
+       in_DCACHE_RSP_VAL        = interface->set_signal_valack_in (VAL);
+      out_DCACHE_RSP_ACK        = interface->set_signal_valack_out(ACK);
+       if (_param->_have_port_dcache_context_id)
+       in_DCACHE_RSP_CONTEXT_ID = interface->set_signal_in  <Tcontext_t     > ("context_id",_param->_size_dcache_context_id  );
+       in_DCACHE_RSP_PACKET_ID  = interface->set_signal_in  <Tpacket_t      > ("packet_id" ,_param->_size_dcache_packet_id   );
+       in_DCACHE_RSP_RDATA      = interface->set_signal_in  <Tdcache_data_t > ("rdata"     ,_param->_size_general_data);
+       in_DCACHE_RSP_ERROR      = interface->set_signal_in  <Tdcache_error_t> ("error"     ,_param->_size_dcache_error);
+      ALLOC1_VALACK_IN ( in_DCACHE_RSP_VAL        ,VAL);
+      ALLOC1_VALACK_OUT(out_DCACHE_RSP_ACK        ,ACK);
+      ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_CONTEXT_ID ,"context_id",Tcontext_t     ,_param->_size_dcache_context_id  );
+      ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_PACKET_ID  ,"packet_id" ,Tpacket_t      ,_param->_size_dcache_packet_id   );
+      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);
+    }
     // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//  if (_param->_speculative_load == SPECULATIVE_LOAD_BYPASS)
+      {
+        out_BYPASS_MEMORY_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_bypass_memory];
+        if (_param->_have_port_ooo_engine_id)
+        out_BYPASS_MEMORY_OOO_ENGINE_ID= new SC_OUT(Tcontext_t        ) * [_param->_nb_bypass_memory];
+        out_BYPASS_MEMORY_NUM_REG      = new SC_OUT(Tgeneral_address_t) * [_param->_nb_bypass_memory];
+        out_BYPASS_MEMORY_DATA         = new SC_OUT(Tgeneral_data_t   ) * [_param->_nb_bypass_memory];
+        for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
+          {
+            Interface_fifo * interface = _interfaces->set_interface("memory_out"
+#ifdef POSITION
+                                                                    ,OUT
+                                                                    ,NORTH
+                                                                    ,"Bypass between the load queue and the reservation station"
+#endif
+                                                                    );
+    {
+      ALLOC1_INTERFACE("bypass_memory",OUT,NORTH,_("Bypass between the load queue and the reservation station"),_param->_nb_bypass_memory);
+            out_BYPASS_MEMORY_VAL           [i] = interface->set_signal_valack_out(VAL);
+            if (_param->_have_port_ooo_engine_id)
+            out_BYPASS_MEMORY_OOO_ENGINE_ID [i] = interface->set_signal_out <Tcontext_t        > ("ooo_engine_id", _param->_size_ooo_engine_id);
+            out_BYPASS_MEMORY_NUM_REG       [i] = interface->set_signal_out <Tgeneral_address_t> ("num_reg"      , _param->_size_general_register);
+            out_BYPASS_MEMORY_DATA          [i] = interface->set_signal_out <Tgeneral_data_t   > ("data"         , _param->_size_general_data);
+          }
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      ALLOC1_VALACK_OUT(out_BYPASS_MEMORY_VAL           ,VAL);
+      ALLOC1_SIGNAL_OUT(out_BYPASS_MEMORY_OOO_ENGINE_ID ,"ooo_engine_id",Tcontext_t        , _param->_size_ooo_engine_id   );
+      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    );
+    }
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ = new Tlsq_ptr_t [_param->_nb_cache_port];
+//     internal_MEMORY_IN_ACK           = new Tcontrol_t      [_param->_nb_inst_memory];
+//     internal_MEMORY_OUT_VAL          = new Tcontrol_t      [_param->_nb_inst_memory];
+//     internal_MEMORY_OUT_SELECT_QUEUE = new Tselect_queue_t [_param->_nb_inst_memory];
+//     internal_MEMORY_OUT_PTR          = new Tlsq_ptr_t      [_param->_nb_inst_memory];
+//     internal_DCACHE_RSP_ACK          = new Tcontrol_t      [_param->_nb_cache_port];
+//     internal_DCACHE_REQ_VAL          = new Tcontrol_t      [_param->_nb_cache_port];
+//     internal_DCACHE_REQ_SELECT_QUEUE = new Tselect_queue_t [_param->_nb_cache_port];
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_deallocation.cpp

-              r81
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/include/Load_store_unit.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     delete    in_CLOCK ;
 …
     delete    in_NRESET;
+    delete     in_MEMORY_IN_VAL         ;
+    delete    out_MEMORY_IN_ACK         ;
+    if (_param->_have_port_context_id)
+    delete     in_MEMORY_IN_CONTEXT_ID  ;
+    if (_param->_have_port_front_end_id)
+    delete     in_MEMORY_IN_FRONT_END_ID  ;
+    if (_param->_have_port_ooo_engine_id)
+    delete     in_MEMORY_IN_OOO_ENGINE_ID  ;
+    if (_param->_have_port_packet_id)
+    delete     in_MEMORY_IN_PACKET_ID   ;
+    delete     in_MEMORY_IN_OPERATION   ;
+    delete     in_MEMORY_IN_TYPE        ;
+    delete     in_MEMORY_IN_STORE_QUEUE_PTR_WRITE;
+    if (_param->_have_port_load_queue_ptr)
+    delete     in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ;
+    delete     in_MEMORY_IN_HAS_IMMEDIAT;
+    delete     in_MEMORY_IN_IMMEDIAT    ;
+    delete     in_MEMORY_IN_DATA_RA     ;
+    delete     in_MEMORY_IN_DATA_RB     ;
+    delete     in_MEMORY_IN_DATA_RC     ;
+    delete     in_MEMORY_IN_WRITE_RD    ;
+    delete     in_MEMORY_IN_NUM_REG_RD  ;
+    delete     in_MEMORY_IN_WRITE_RE    ;
+    delete     in_MEMORY_IN_NUM_REG_RE  ;
+    DELETE1_SIGNAL( in_MEMORY_IN_VAL                  ,_param->_nb_inst_memory,1);
+    DELETE1_SIGNAL(out_MEMORY_IN_ACK                  ,_param->_nb_inst_memory,1);
+    DELETE1_SIGNAL( in_MEMORY_IN_CONTEXT_ID           ,_param->_nb_inst_memory,_param->_size_context_id           );
+    DELETE1_SIGNAL( in_MEMORY_IN_FRONT_END_ID         ,_param->_nb_inst_memory,_param->_size_front_end_id         );
+    DELETE1_SIGNAL( in_MEMORY_IN_OOO_ENGINE_ID        ,_param->_nb_inst_memory,_param->_size_ooo_engine_id        );
+    DELETE1_SIGNAL( in_MEMORY_IN_PACKET_ID            ,_param->_nb_inst_memory,_param->_size_rob_ptr              );
+    DELETE1_SIGNAL( in_MEMORY_IN_OPERATION            ,_param->_nb_inst_memory,_param->_size_operation            );
+    DELETE1_SIGNAL( in_MEMORY_IN_TYPE                 ,_param->_nb_inst_memory,_param->_size_type                 );
+    DELETE1_SIGNAL( in_MEMORY_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_memory,_param->_size_store_queue_ptr      );
+    DELETE1_SIGNAL( in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_inst_memory,_param->_size_load_queue_ptr       );
+    DELETE1_SIGNAL( in_MEMORY_IN_HAS_IMMEDIAT         ,_param->_nb_inst_memory,1                                  );
+    DELETE1_SIGNAL( in_MEMORY_IN_IMMEDIAT             ,_param->_nb_inst_memory,_param->_size_general_data         );
+    DELETE1_SIGNAL( in_MEMORY_IN_DATA_RA              ,_param->_nb_inst_memory,_param->_size_general_data         );
+    DELETE1_SIGNAL( in_MEMORY_IN_DATA_RB              ,_param->_nb_inst_memory,_param->_size_general_data         );
+    DELETE1_SIGNAL( in_MEMORY_IN_DATA_RC              ,_param->_nb_inst_memory,_param->_size_special_data         );
+    DELETE1_SIGNAL( in_MEMORY_IN_WRITE_RD             ,_param->_nb_inst_memory,1                                  );
+    DELETE1_SIGNAL( in_MEMORY_IN_NUM_REG_RD           ,_param->_nb_inst_memory,1                                  );
+    DELETE1_SIGNAL( in_MEMORY_IN_WRITE_RE             ,_param->_nb_inst_memory,1                                  );
+    DELETE1_SIGNAL( in_MEMORY_IN_NUM_REG_RE           ,_param->_nb_inst_memory,1                                  );
+    DELETE1_SIGNAL(out_MEMORY_OUT_VAL          ,_param->_nb_inst_memory,1);
+    DELETE1_SIGNAL( in_MEMORY_OUT_ACK          ,_param->_nb_inst_memory,1);
+    DELETE1_SIGNAL(out_MEMORY_OUT_CONTEXT_ID   ,_param->_nb_inst_memory,_param->_size_context_id       );
+    DELETE1_SIGNAL(out_MEMORY_OUT_FRONT_END_ID ,_param->_nb_inst_memory,_param->_size_front_end_id     );
+    DELETE1_SIGNAL(out_MEMORY_OUT_OOO_ENGINE_ID,_param->_nb_inst_memory,_param->_size_ooo_engine_id    );
+    DELETE1_SIGNAL(out_MEMORY_OUT_PACKET_ID    ,_param->_nb_inst_memory,_param->_size_rob_ptr          );
+//  DELETE1_SIGNAL(out_MEMORY_OUT_OPERATION    ,_param->_nb_inst_memory,_param->_size_operation        );
+    DELETE1_SIGNAL(out_MEMORY_OUT_TYPE         ,_param->_nb_inst_memory,_param->_size_type             );
+    DELETE1_SIGNAL(out_MEMORY_OUT_WRITE_RD     ,_param->_nb_inst_memory,1                              );
+    DELETE1_SIGNAL(out_MEMORY_OUT_NUM_REG_RD   ,_param->_nb_inst_memory,_param->_size_general_register );
+    DELETE1_SIGNAL(out_MEMORY_OUT_DATA_RD      ,_param->_nb_inst_memory,_param->_size_general_data     );
+    DELETE1_SIGNAL(out_MEMORY_OUT_WRITE_RE     ,_param->_nb_inst_memory,1                              );
+    DELETE1_SIGNAL(out_MEMORY_OUT_NUM_REG_RE   ,_param->_nb_inst_memory,_param->_size_general_register );
+    DELETE1_SIGNAL(out_MEMORY_OUT_DATA_RE      ,_param->_nb_inst_memory,_param->_size_general_data     );
+    DELETE1_SIGNAL(out_MEMORY_OUT_EXCEPTION    ,_param->_nb_inst_memory,_param->_size_exception        );
+    DELETE1_SIGNAL(out_MEMORY_OUT_NO_SEQUENCE  ,_param->_nb_inst_memory,1                              );
+    DELETE1_SIGNAL(out_MEMORY_OUT_ADDRESS      ,_param->_nb_inst_memory,_param->_size_general_data     );
+    DELETE1_SIGNAL(out_DCACHE_REQ_VAL        ,_param->_nb_cache_port,1);
+    DELETE1_SIGNAL( in_DCACHE_REQ_ACK        ,_param->_nb_cache_port,1);
+    DELETE1_SIGNAL(out_DCACHE_REQ_CONTEXT_ID ,_param->_nb_cache_port,_param->_size_dcache_context_id  );
+    DELETE1_SIGNAL(out_DCACHE_REQ_PACKET_ID  ,_param->_nb_cache_port,_param->_size_dcache_packet_id   );
+    DELETE1_SIGNAL(out_DCACHE_REQ_ADDRESS    ,_param->_nb_cache_port,_param->_size_general_data);
+    DELETE1_SIGNAL(out_DCACHE_REQ_TYPE       ,_param->_nb_cache_port,_param->_size_dcache_type );
+    DELETE1_SIGNAL(out_DCACHE_REQ_WDATA      ,_param->_nb_cache_port,_param->_size_general_data);
+    DELETE1_SIGNAL( in_DCACHE_RSP_VAL        ,_param->_nb_cache_port,1);
+    DELETE1_SIGNAL(out_DCACHE_RSP_ACK        ,_param->_nb_cache_port,1);
+    DELETE1_SIGNAL( in_DCACHE_RSP_CONTEXT_ID ,_param->_nb_cache_port,_param->_size_dcache_context_id  );
+    DELETE1_SIGNAL( in_DCACHE_RSP_PACKET_ID  ,_param->_nb_cache_port,_param->_size_dcache_packet_id   );
+    DELETE1_SIGNAL( in_DCACHE_RSP_RDATA      ,_param->_nb_cache_port,_param->_size_general_data);
+    DELETE1_SIGNAL( in_DCACHE_RSP_ERROR      ,_param->_nb_cache_port,_param->_size_dcache_error);
+    DELETE1_SIGNAL(out_BYPASS_MEMORY_VAL           ,_param->_nb_bypass_memory,1);
+    DELETE1_SIGNAL(out_BYPASS_MEMORY_OOO_ENGINE_ID ,_param->_nb_bypass_memory,_param->_size_ooo_engine_id   );
+    DELETE1_SIGNAL(out_BYPASS_MEMORY_NUM_REG       ,_param->_nb_bypass_memory,_param->_size_general_register);
+    DELETE1_SIGNAL(out_BYPASS_MEMORY_DATA          ,_param->_nb_bypass_memory,_param->_size_general_data    );
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete    out_MEMORY_OUT_VAL       ;
+    delete     in_MEMORY_OUT_ACK       ;
+    if (_param->_have_port_context_id)
+    delete    out_MEMORY_OUT_CONTEXT_ID;
+    if (_param->_have_port_front_end_id)
+    delete    out_MEMORY_OUT_FRONT_END_ID;
+    if (_param->_have_port_ooo_engine_id)
+      delete    out_MEMORY_OUT_OOO_ENGINE_ID;
+    if (_param->_have_port_packet_id)
+    delete    out_MEMORY_OUT_PACKET_ID ;
+//  delete    out_MEMORY_OUT_OPERATION ;
+    delete    out_MEMORY_OUT_TYPE      ;
+    delete    out_MEMORY_OUT_WRITE_RD  ;
+    delete    out_MEMORY_OUT_NUM_REG_RD;
+    delete    out_MEMORY_OUT_DATA_RD   ;
+    delete    out_MEMORY_OUT_WRITE_RE  ;
+    delete    out_MEMORY_OUT_NUM_REG_RE;
+    delete    out_MEMORY_OUT_DATA_RE   ;
+    delete    out_MEMORY_OUT_EXCEPTION ;
+    delete    out_MEMORY_OUT_NO_SEQUENCE;
+    delete    out_MEMORY_OUT_ADDRESS   ;
+//     delete [] internal_MEMORY_IN_ACK          ;
+//     delete [] internal_MEMORY_OUT_VAL         ;
+//     delete [] internal_MEMORY_OUT_SELECT_QUEUE;
+//     delete [] internal_MEMORY_OUT_PTR         ;
+    delete    out_DCACHE_REQ_VAL       ;
+    delete     in_DCACHE_REQ_ACK       ;
+    if (_param->_have_port_dcache_context_id)
+    delete    out_DCACHE_REQ_CONTEXT_ID;
+    delete    out_DCACHE_REQ_PACKET_ID ;
+    delete    out_DCACHE_REQ_ADDRESS   ;
+    delete    out_DCACHE_REQ_TYPE      ;
+    delete    out_DCACHE_REQ_WDATA     ;
+    delete     in_DCACHE_RSP_VAL       ;
+    delete    out_DCACHE_RSP_ACK       ;
+    if (_param->_have_port_dcache_context_id)
+    delete     in_DCACHE_RSP_CONTEXT_ID;
+    delete     in_DCACHE_RSP_PACKET_ID ;
+    delete     in_DCACHE_RSP_RDATA     ;
+    delete     in_DCACHE_RSP_ERROR     ;
+    delete [] out_BYPASS_MEMORY_VAL       ;
+    if (_param->_have_port_ooo_engine_id)
+    delete [] out_BYPASS_MEMORY_OOO_ENGINE_ID;
+    delete [] out_BYPASS_MEMORY_NUM_REG   ;
+    delete [] out_BYPASS_MEMORY_DATA      ;
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     delete [] internal_DCACHE_RSP_ACK         ;
+//     delete [] internal_DCACHE_REQ_VAL         ;
+//     delete [] internal_DCACHE_REQ_SELECT_QUEUE;
+//     delete [] internal_SPECULATIVE_ACCESS_QUEUE_PTR_READ;
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete    _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Load_store_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

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_genMealy_insert.cpp

-              r81
+              r88
     // ~~~~~[ Output "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // Initialisation
+    internal_MEMORY_IN_PORT = 0;
+    Tcontrol_t ack [_param->_nb_inst_memory];
+    for (uint32_t i=0; i<_param->_nb_inst_memory; i++)
+      ack [i] = 0;
+    // find first valid entry
     // store queue is never full (pointer is manage by rename stage)
+    internal_MEMORY_IN_ACK = is_operation_memory_store(PORT_READ(in_MEMORY_IN_OPERATION)) or not _speculative_access_queue_control->full();
+    for (uint32_t i=0; i<_param->_nb_inst_memory; i++)
+      if (PORT_READ(in_MEMORY_IN_VAL [i]))
+        {
+          internal_MEMORY_IN_ACK = is_operation_memory_store(PORT_READ(in_MEMORY_IN_OPERATION [i])) or not _speculative_access_queue_control->full();
+    PORT_WRITE(out_MEMORY_IN_ACK, internal_MEMORY_IN_ACK);
+          if (internal_MEMORY_IN_ACK)
+            {
+              ack [i] = 1;
+              internal_MEMORY_IN_PORT = i;
+              break; // end
+            }
+        }
+    for (uint32_t i=0; i<_param->_nb_inst_memory; i++)
+      PORT_WRITE(out_MEMORY_IN_ACK [i], ack [i]);
     log_printf(FUNC,Load_store_unit,FUNCTION,"End");

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_genMoore.cpp

-              r81
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
     // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     Tcontext_t         memory_out_context_id    = 0;
 …
+      }
     // write output
     PORT_WRITE(out_MEMORY_OUT_VAL          , internal_MEMORY_OUT_VAL);
+    PORT_WRITE(out_MEMORY_OUT_VAL          [0], internal_MEMORY_OUT_VAL);
     if (_param->_have_port_context_id)
     PORT_WRITE(out_MEMORY_OUT_CONTEXT_ID   , memory_out_context_id   );
+    PORT_WRITE(out_MEMORY_OUT_CONTEXT_ID   [0], memory_out_context_id   );
     if (_param->_have_port_front_end_id)
     PORT_WRITE(out_MEMORY_OUT_FRONT_END_ID , memory_out_front_end_id );
+    PORT_WRITE(out_MEMORY_OUT_FRONT_END_ID [0], memory_out_front_end_id );
     if (_param->_have_port_ooo_engine_id)
+    PORT_WRITE(out_MEMORY_OUT_OOO_ENGINE_ID, memory_out_ooo_engine_id);
+    if (_param->_have_port_packet_id)
+    PORT_WRITE(out_MEMORY_OUT_PACKET_ID    , memory_out_packet_id    );
+//  PORT_WRITE(out_MEMORY_OUT_OPERATION    , memory_out_operation    );
+    PORT_WRITE(out_MEMORY_OUT_TYPE         , TYPE_MEMORY             );
+    PORT_WRITE(out_MEMORY_OUT_WRITE_RD     , memory_out_write_rd     );
+    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RD   , memory_out_num_reg_rd   );
+    PORT_WRITE(out_MEMORY_OUT_DATA_RD      , memory_out_data_rd      );
+//  PORT_WRITE(out_MEMORY_OUT_WRITE_RE     , memory_out_write_re     );
+//  PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   , memory_out_num_reg_re   );
+//  PORT_WRITE(out_MEMORY_OUT_DATA_RE      , memory_out_data_re      );
+    PORT_WRITE(out_MEMORY_OUT_WRITE_RE     , 0);
+    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   , 0);
+    PORT_WRITE(out_MEMORY_OUT_DATA_RE      , 0);
+    PORT_WRITE(out_MEMORY_OUT_EXCEPTION    , memory_out_exception    );
+    PORT_WRITE(out_MEMORY_OUT_NO_SEQUENCE  , 0);
+    PORT_WRITE(out_MEMORY_OUT_ADDRESS      , 0);
+    // ~~~~~[ Interface "dache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    PORT_WRITE(out_MEMORY_OUT_OOO_ENGINE_ID[0], memory_out_ooo_engine_id);
+    if (_param->_have_port_rob_ptr)
+    PORT_WRITE(out_MEMORY_OUT_PACKET_ID    [0], memory_out_packet_id    );
+//  PORT_WRITE(out_MEMORY_OUT_OPERATION    [0], memory_out_operation    );
+    PORT_WRITE(out_MEMORY_OUT_TYPE         [0], TYPE_MEMORY             );
+    PORT_WRITE(out_MEMORY_OUT_WRITE_RD     [0], memory_out_write_rd     );
+    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RD   [0], memory_out_num_reg_rd   );
+    PORT_WRITE(out_MEMORY_OUT_DATA_RD      [0], memory_out_data_rd      );
+//  PORT_WRITE(out_MEMORY_OUT_WRITE_RE     [0], memory_out_write_re     );
+//  PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   [0], memory_out_num_reg_re   );
+//  PORT_WRITE(out_MEMORY_OUT_DATA_RE      [0], memory_out_data_re      );
+    PORT_WRITE(out_MEMORY_OUT_WRITE_RE     [0], 0);
+    PORT_WRITE(out_MEMORY_OUT_NUM_REG_RE   [0], 0);
+    PORT_WRITE(out_MEMORY_OUT_DATA_RE      [0], 0);
+    PORT_WRITE(out_MEMORY_OUT_EXCEPTION    [0], memory_out_exception    );
+    PORT_WRITE(out_MEMORY_OUT_NO_SEQUENCE  [0], 0);
+    PORT_WRITE(out_MEMORY_OUT_ADDRESS      [0], 0);
+    // ~~~~~[ Interface "dache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     Tcontext_t        dcache_req_context_id;
 …
+      }
     PORT_WRITE(out_DCACHE_REQ_VAL       , internal_DCACHE_REQ_VAL);
+    PORT_WRITE(out_DCACHE_REQ_VAL       [0], internal_DCACHE_REQ_VAL);
     if (_param->_have_port_dcache_context_id)
     PORT_WRITE(out_DCACHE_REQ_CONTEXT_ID, dcache_req_context_id);
     PORT_WRITE(out_DCACHE_REQ_PACKET_ID , dcache_req_packet_id );
     PORT_WRITE(out_DCACHE_REQ_ADDRESS   , dcache_req_address   );
     PORT_WRITE(out_DCACHE_REQ_TYPE      , dcache_req_type      );
     PORT_WRITE(out_DCACHE_REQ_WDATA     , dcache_req_wdata     );
+    PORT_WRITE(out_DCACHE_REQ_CONTEXT_ID[0], dcache_req_context_id);
+    PORT_WRITE(out_DCACHE_REQ_PACKET_ID [0], dcache_req_packet_id );
+    PORT_WRITE(out_DCACHE_REQ_ADDRESS   [0], dcache_req_address   );
+    PORT_WRITE(out_DCACHE_REQ_TYPE      [0], dcache_req_type      );
+    PORT_WRITE(out_DCACHE_REQ_WDATA     [0], dcache_req_wdata     );
     log_printf(FUNC,Load_store_unit,FUNCTION,"End");

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

-              r81
+              r88
         // Interface "MEMORY_IN"
         //================================================================
         if ((PORT_READ(in_MEMORY_IN_VAL) == 1) and
+        if ((PORT_READ(in_MEMORY_IN_VAL [internal_MEMORY_IN_PORT]) == 1) and
             (    internal_MEMORY_IN_ACK  == 1))
+          {
 …
 #ifdef DEBUG_TEST
             if (PORT_READ(in_MEMORY_IN_TYPE) != TYPE_MEMORY)
+            if (PORT_READ(in_MEMORY_IN_TYPE [internal_MEMORY_IN_PORT]) != TYPE_MEMORY)
               throw ERRORMORPHEO(FUNCTION,"The type is different at 'TYPE_MEMORY'");
 #endif
             Toperation_t    operation            = PORT_READ(in_MEMORY_IN_OPERATION);
             Tgeneral_data_t address              = (PORT_READ(in_MEMORY_IN_IMMEDIAT) +
                                                     PORT_READ(in_MEMORY_IN_DATA_RA ));
+            Toperation_t    operation            = PORT_READ(in_MEMORY_IN_OPERATION[internal_MEMORY_IN_PORT]);
+            Tgeneral_data_t address              = (PORT_READ(in_MEMORY_IN_IMMEDIAT[internal_MEMORY_IN_PORT]) +
+                                                    PORT_READ(in_MEMORY_IN_DATA_RA [internal_MEMORY_IN_PORT]));
             bool            exception_alignement = (mask_memory_access(operation) & address) != 0;
 …
                 // Write pointer is define in rename stage :
                 Tlsq_ptr_t           index         = PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_WRITE);
+                Tlsq_ptr_t           index         = PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
                 log_printf(TRACE,Load_store_unit,FUNCTION,"   * index         : %d",index);
 …
                     log_printf(TRACE,Load_store_unit,FUNCTION,"   * Update information");
                     _store_queue [index]._context_id           = (not _param->_have_port_context_id   )?0:PORT_READ(in_MEMORY_IN_CONTEXT_ID);
                     _store_queue [index]._front_end_id         = (not _param->_have_port_front_end_id )?0:PORT_READ(in_MEMORY_IN_FRONT_END_ID);
                     _store_queue [index]._ooo_engine_id        = (not _param->_have_port_ooo_engine_id)?0:PORT_READ(in_MEMORY_IN_OOO_ENGINE_ID);
                     _store_queue [index]._packet_id            = (not _param->_have_port_packet_id    )?0:PORT_READ(in_MEMORY_IN_PACKET_ID   );
+                    _store_queue [index]._context_id           = (not _param->_have_port_context_id   )?0:PORT_READ(in_MEMORY_IN_CONTEXT_ID   [internal_MEMORY_IN_PORT]);
+                    _store_queue [index]._front_end_id         = (not _param->_have_port_front_end_id )?0:PORT_READ(in_MEMORY_IN_FRONT_END_ID [internal_MEMORY_IN_PORT]);
+                    _store_queue [index]._ooo_engine_id        = (not _param->_have_port_ooo_engine_id)?0:PORT_READ(in_MEMORY_IN_OOO_ENGINE_ID[internal_MEMORY_IN_PORT]);
+                    _store_queue [index]._packet_id            = (not _param->_have_port_rob_ptr      )?0:PORT_READ(in_MEMORY_IN_PACKET_ID    [internal_MEMORY_IN_PORT]);
                     _store_queue [index]._operation            = operation;
                     _store_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE);
+                    _store_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
                     _store_queue [index]._address              = address;
                     // reordering data
                     _store_queue [index]._wdata                = duplicate<Tgeneral_data_t>(_param->_size_general_data,PORT_READ(in_MEMORY_IN_DATA_RB), memory_size(operation), 0);
 //                  _store_queue [index]._num_reg_rd           = PORT_READ(in_MEMORY_IN_NUM_REG_RD  );
+                    _store_queue [index]._wdata                = duplicate<Tgeneral_data_t>(_param->_size_general_data,PORT_READ(in_MEMORY_IN_DATA_RB[internal_MEMORY_IN_PORT]), memory_size(operation), 0);
+//                  _store_queue [index]._num_reg_rd           = PORT_READ(in_MEMORY_IN_NUM_REG_RD  [internal_MEMORY_IN_PORT]);
+                  }
+              }
 …
                 // NOTE : type "other" (lock, invalidate, flush and sync) can't make an alignement exception (access is equivalent at a 8 bits)
                 _speculative_access_queue [index]._state                = (exception == EXCEPTION_MEMORY_NONE)?SPECULATIVE_ACCESS_QUEUE_WAIT_CACHE:SPECULATIVE_ACCESS_QUEUE_WAIT_LOAD_QUEUE;
                 _speculative_access_queue [index]._context_id           = (not _param->_have_port_context_id   )?0:PORT_READ(in_MEMORY_IN_CONTEXT_ID);
                 _speculative_access_queue [index]._front_end_id         = (not _param->_have_port_front_end_id )?0:PORT_READ(in_MEMORY_IN_FRONT_END_ID);
                 _speculative_access_queue [index]._ooo_engine_id        = (not _param->_have_port_ooo_engine_id)?0:PORT_READ(in_MEMORY_IN_OOO_ENGINE_ID);
                 _speculative_access_queue [index]._packet_id            = (not _param->_have_port_packet_id    )?0:PORT_READ(in_MEMORY_IN_PACKET_ID);
+                _speculative_access_queue [index]._context_id           = (not _param->_have_port_context_id   )?0:PORT_READ(in_MEMORY_IN_CONTEXT_ID   [internal_MEMORY_IN_PORT]);
+                _speculative_access_queue [index]._front_end_id         = (not _param->_have_port_front_end_id )?0:PORT_READ(in_MEMORY_IN_FRONT_END_ID [internal_MEMORY_IN_PORT]);
+                _speculative_access_queue [index]._ooo_engine_id        = (not _param->_have_port_ooo_engine_id)?0:PORT_READ(in_MEMORY_IN_OOO_ENGINE_ID[internal_MEMORY_IN_PORT]);
+                _speculative_access_queue [index]._packet_id            = (not _param->_have_port_rob_ptr      )?0:PORT_READ(in_MEMORY_IN_PACKET_ID    [internal_MEMORY_IN_PORT]);
                 _speculative_access_queue [index]._operation            = operation;
                 _speculative_access_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE);
                 _speculative_access_queue [index]._store_queue_ptr_write= PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_WRITE);
+                _speculative_access_queue [index]._load_queue_ptr_write = (not _param->_have_port_load_queue_ptr)?0:PORT_READ(in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
+                _speculative_access_queue [index]._store_queue_ptr_write= PORT_READ(in_MEMORY_IN_STORE_QUEUE_PTR_WRITE[internal_MEMORY_IN_PORT]);
                 _speculative_access_queue [index]._address              = address;
                 // NOTE : is operation is a load, then they are a result and must write in the register file
                 _speculative_access_queue [index]._write_rd             = is_operation_memory_load(operation);
                 _speculative_access_queue [index]._num_reg_rd           = PORT_READ(in_MEMORY_IN_NUM_REG_RD  );
+                _speculative_access_queue [index]._num_reg_rd           = PORT_READ(in_MEMORY_IN_NUM_REG_RD  [internal_MEMORY_IN_PORT]);
                 _speculative_access_queue [index]._exception            = exception;
 …
         if ((    internal_MEMORY_OUT_VAL  == 1) and
             (PORT_READ(in_MEMORY_OUT_ACK) == 1))
+            (PORT_READ(in_MEMORY_OUT_ACK[0]) == 1))
+          {
             log_printf(TRACE,Load_store_unit,FUNCTION,"MEMORY_OUT transaction");
 …
         if ((    internal_DCACHE_REQ_VAL  == 1) and
             (PORT_READ(in_DCACHE_REQ_ACK) == 1))
+            (PORT_READ(in_DCACHE_REQ_ACK[0]) == 1))
+          {
             log_printf(TRACE,Load_store_unit,FUNCTION,"DCACHE_REQ");
 …
         // Interface "DCACHE_RSP"
         //================================================================
         if ((PORT_READ(in_DCACHE_RSP_VAL)== 1) and
+        if ((PORT_READ(in_DCACHE_RSP_VAL[0])== 1) and
             (    internal_DCACHE_RSP_ACK == 1))
+          {
 …
             // don't use context_id : because there are one queue for all thread
             //Tcontext_t      context_id = PORT_READ(in_DCACHE_RSP_CONTEXT_ID);
             Tpacket_t       packet_id  = PORT_READ(in_DCACHE_RSP_PACKET_ID );
             Tdcache_data_t  rdata      = PORT_READ(in_DCACHE_RSP_RDATA     );
             Tdcache_error_t error      = PORT_READ(in_DCACHE_RSP_ERROR     );
+            //Tcontext_t      context_id = PORT_READ(in_DCACHE_RSP_CONTEXT_ID[0]);
+            Tpacket_t       packet_id  = PORT_READ(in_DCACHE_RSP_PACKET_ID [0]);
+            Tdcache_data_t  rdata      = PORT_READ(in_DCACHE_RSP_RDATA     [0]);
+            Tdcache_error_t error      = PORT_READ(in_DCACHE_RSP_ERROR     [0]);
             log_printf(TRACE,Load_store_unit,FUNCTION," * original packet_id : %d", packet_id);
 …
 #if DEBUG>=DEBUG_TRACE
+#if defined(DEBUG) and (DEBUG>=DEBUG_TRACE)
         // ***** dump store queue
         std::cout << "Dump STORE_QUEUE :" << std::endl
 …
                  << _load_queue[j] << std::endl;
+          }
 #endif
 #ifdef STATISTICS
+        for (uint32_t i=0; i<_param->_size_store_queue; i++)
+          if (_store_queue[i]._state != STORE_QUEUE_EMPTY)
+            (*_stat_use_store_queue) ++;
+        for (uint32_t i=0; i<_param->_size_speculative_access_queue; i++)
+          if (_speculative_access_queue[i]._state != SPECULATIVE_ACCESS_QUEUE_EMPTY)
+            (*_stat_use_speculative_access_queue) ++;
+        for (uint32_t i=0; i<_param->_size_load_queue; i++)
+          if (_load_queue[i]._state != LOAD_QUEUE_EMPTY)
+            (*_stat_use_load_queue) ++;
+        if (usage_is_set(_usage,USE_STATISTICS))
+          {
+            for (uint32_t i=0; i<_param->_size_store_queue; i++)
+              if (_store_queue[i]._state != STORE_QUEUE_EMPTY)
+                (*_stat_use_store_queue) ++;
+            for (uint32_t i=0; i<_param->_size_speculative_access_queue; i++)
+              if (_speculative_access_queue[i]._state != SPECULATIVE_ACCESS_QUEUE_EMPTY)
+                (*_stat_use_speculative_access_queue) ++;
+            for (uint32_t i=0; i<_param->_size_load_queue; i++)
+              if (_load_queue[i]._state != LOAD_QUEUE_EMPTY)
+                (*_stat_use_load_queue) ++;
+          }
 #endif
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters.cpp

-              r81
+              r88
                           Tspeculative_load_t speculative_load       ,
                           uint32_t            nb_bypass_memory       ,
+                          uint32_t            nb_cache_port          ,
+                          uint32_t            nb_inst_memory         ,
                           uint32_t            nb_context             ,
                           uint32_t            nb_front_end           ,
 …
                           uint32_t            size_special_data      ,
                           uint32_t            nb_general_register    ,
+                          uint32_t            nb_special_register    ):
+    _size_store_queue        (size_store_queue       ),
+    _size_load_queue         (size_load_queue        ),
+    _size_speculative_access_queue (size_speculative_access_queue),
+    _nb_port_check           (nb_port_check          ),
+    _speculative_load        (speculative_load       ),
+    _nb_bypass_memory        (nb_bypass_memory       ),
+    _nb_context              (nb_context             ),
+    _nb_front_end            (nb_front_end           ),
+    _nb_ooo_engine           (nb_ooo_engine          ),
+    _nb_packet               (nb_packet              ),
+    _size_general_data       (size_general_data      ),
+    _size_special_data       (size_special_data      ),
+    _nb_general_register     (nb_general_register    ),
+    _nb_special_register     (nb_special_register    ),
+    _size_address_store_queue              (log2(size_store_queue             )),
+    _size_address_load_queue               (log2(size_load_queue              )),
+    _size_address_speculative_access_queue (log2(size_speculative_access_queue)),
+    _size_context_id         (log2(nb_context         )),
+    _size_front_end_id       (log2(nb_front_end       )),
+    _size_ooo_engine_id      (log2(nb_ooo_engine      )),
+    _size_packet_id          (log2(nb_packet          )),
+    _size_general_register   (log2(nb_general_register)),
+    _size_special_register   (log2(nb_special_register)),
+    _size_dcache_context_id  (_size_context_id + _size_front_end_id + _size_ooo_engine_id),
+    _size_dcache_packet_id   ((log2((size_store_queue>size_load_queue)?size_store_queue:size_load_queue))+1),
+    _have_port_context_id        (_size_context_id   >0),
+    _have_port_front_end_id      (_size_front_end_id >0),
+    _have_port_ooo_engine_id     (_size_ooo_engine_id>0),
+    _have_port_packet_id         (_size_packet_id    >0),
+    _have_port_dcache_context_id (_size_dcache_context_id>0),
+    _have_port_load_queue_ptr    (_size_load_queue>1),
+    _mask_address_lsb            (gen_mask<Tdcache_address_t>(log2(size_general_data/8))),
+    _mask_address_msb            (gen_mask<Tdcache_address_t>(size_general_data) << log2(size_general_data/8))
+                          uint32_t            nb_special_register    ,
+                          bool                is_toplevel)
+  {
     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
+    _size_store_queue                      = size_store_queue       ;
+    _size_load_queue                       = size_load_queue        ;
+    _size_speculative_access_queue         = size_speculative_access_queue;
+    _nb_port_check                         = nb_port_check          ;
+    _speculative_load                      = speculative_load       ;
+    _nb_bypass_memory                      = nb_bypass_memory       ;
+    _nb_cache_port                         = nb_cache_port          ;
+    _nb_inst_memory                        = nb_inst_memory         ;
+    _nb_context                            = nb_context             ;
+    _nb_front_end                          = nb_front_end           ;
+    _nb_ooo_engine                         = nb_ooo_engine          ;
+    _nb_packet                             = nb_packet              ;
+    _nb_general_register                   = nb_general_register    ;
+    _nb_special_register                   = nb_special_register    ;
+    _size_speculative_access_queue_ptr     = log2(size_speculative_access_queue);
+    _size_dcache_context_id                = log2(nb_context) + log2(nb_front_end) + log2(nb_ooo_engine);
+    _size_dcache_packet_id                 = (log2((size_store_queue>size_load_queue)?size_store_queue:size_load_queue))+1;
+    _have_port_dcache_context_id           = _size_dcache_context_id>0;
+    _mask_address_lsb                      = gen_mask<Tdcache_address_t>(log2(size_general_data/8));
+    _mask_address_msb                      = gen_mask<Tdcache_address_t>(size_general_data) << log2(size_general_data/8);
     test();
+    if (is_toplevel)
+      {
+        _size_context_id                       = log2(nb_context         );
+        _size_front_end_id                     = log2(nb_front_end       );
+        _size_ooo_engine_id                    = log2(nb_ooo_engine      );
+        _size_rob_ptr                          = log2(nb_packet          );
+        _size_general_register                 = log2(nb_general_register);
+        _size_special_register                 = log2(nb_special_register);
+        _size_store_queue_ptr                  = log2(size_store_queue   );
+        _size_load_queue_ptr                   = log2(size_load_queue    );
+        _size_general_data                     = size_general_data      ;
+        _size_special_data                     = size_special_data      ;
+        _have_port_context_id                  = _size_context_id    >0;
+        _have_port_front_end_id                = _size_front_end_id  >0;
+        _have_port_ooo_engine_id               = _size_ooo_engine_id >0;
+        _have_port_rob_ptr                     = _size_rob_ptr       >0;
+        _have_port_load_queue_ptr              = _size_load_queue_ptr>0;
+        copy();
+      }
     log_printf(FUNC,Load_store_unit,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Load_store_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_store_queue        (param._size_store_queue       ),
+//     _size_load_queue         (param._size_load_queue        ),
+//     _size_speculative_access_queue (param._size_speculative_access_queue),
+//     _nb_port_check           (param._nb_port_check          ),
+//     _speculative_load        (param._speculative_load       ),
+//     _nb_bypass_memory        (param._nb_bypass_memory       ),
+//     _nb_cache_port           (param._nb_cache_port          ),
+//     _nb_inst_memory          (param._nb_inst_memory         ),
+//     _nb_context              (param._nb_context             ),
+//     _nb_front_end            (param._nb_front_end           ),
+//     _nb_ooo_engine           (param._nb_ooo_engine          ),
+//     _nb_packet               (param._nb_packet              ),
+//     _size_general_data       (param._size_general_data      ),
+//     _size_special_data       (param._size_special_data      ),
+//     _nb_general_register     (param._nb_general_register    ),
+//     _nb_special_register     (param._nb_special_register    ),
+//     _size_address_store_queue              (param._size_address_store_queue             ),
+//     _size_address_load_queue               (param._size_address_load_queue              ),
+//     _size_address_speculative_access_queue (param._size_address_speculative_access_queue),
+//     _size_context_id         (param._size_context_id        ),
+//     _size_front_end_id       (param._size_front_end_id      ),
+//     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+//     _size_packet_id          (param._size_packet_id         ),
+//     _size_general_register   (param._size_general_register  ),
+//     _size_special_register   (param._size_special_register  ),
+//     _size_dcache_context_id  (param._size_dcache_context_id ),
+//     _size_dcache_packet_id   (param._size_dcache_packet_id  ),
+//     _have_port_context_id    (param._have_port_context_id   ),
+//     _have_port_front_end_id  (param._have_port_front_end_id ),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+//     _have_port_packet_id     (param._have_port_packet_id    ),
+//     _have_port_dcache_context_id(param._have_port_dcache_context_id),
+//     _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
+//     _mask_address_lsb        (param._mask_address_lsb),
+//     _mask_address_msb        (param._mask_address_msb)
+//   {
+//     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Load_store_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Load_store_unit::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _size_store_queue        (param._size_store_queue       ),
+    _size_load_queue         (param._size_load_queue        ),
+    _size_speculative_access_queue (param._size_speculative_access_queue),
+    _nb_port_check           (param._nb_port_check          ),
+    _speculative_load        (param._speculative_load       ),
+    _nb_bypass_memory        (param._nb_bypass_memory       ),
+    _nb_context              (param._nb_context             ),
+    _nb_front_end            (param._nb_front_end           ),
+    _nb_ooo_engine           (param._nb_ooo_engine          ),
+    _nb_packet               (param._nb_packet              ),
+    _size_general_data       (param._size_general_data      ),
+    _size_special_data       (param._size_special_data      ),
+    _nb_general_register     (param._nb_general_register    ),
+    _nb_special_register     (param._nb_special_register    ),
+    _size_address_store_queue              (param._size_address_store_queue             ),
+    _size_address_load_queue               (param._size_address_load_queue              ),
+    _size_address_speculative_access_queue (param._size_address_speculative_access_queue),
+    _size_context_id         (param._size_context_id        ),
+    _size_front_end_id       (param._size_front_end_id      ),
+    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+    _size_packet_id          (param._size_packet_id         ),
+    _size_general_register   (param._size_general_register  ),
+    _size_special_register   (param._size_special_register  ),
+    _size_dcache_context_id  (param._size_dcache_context_id ),
+    _size_dcache_packet_id   (param._size_dcache_packet_id  ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_packet_id     (param._have_port_packet_id    ),
+    _have_port_dcache_context_id(param._have_port_dcache_context_id),
+    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
+    _mask_address_lsb        (param._mask_address_lsb),
+    _mask_address_msb        (param._mask_address_msb)
+#define FUNCTION "Load_store_unit::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");
-    test();
     log_printf(FUNC,Load_store_unit,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Load_store_unit::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Load_store_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Load_store_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit/src/Parameters_msg_error.cpp

-              r81
+              r88
+        {
           if (not (_nb_bypass_memory == 0))
             test.error("Bypass memory is not supported. Please wait a next revision.");
+            test.error(_("Bypass memory is not supported. Please wait a next revision.\n"));
           break;
 …
+        {
           if (not (_nb_bypass_memory == 0))
             test.error("In the load scheme '"+toString(_speculative_load)+"', they have none bypass.");
+            test.error(toString(_("In the load scheme '%s', they have none bypass.\n"),toString(_speculative_load).c_str()));
           test.error("Speculative load scheme '"+toString(_speculative_load)+"' is not supported. Please wait a next revision.");
+          test.error(toString(_("Speculative load scheme '%s' is not supported. Please wait a next revision.\n"),toString(_speculative_load).c_str()));
           break;
+        }
 …
     if (not (_size_store_queue >= 2))
       test.error("Store queue must have at less two slot.");
+      test.error(_("Store queue must have at less two slot.\n"));
     if (not (_nb_bypass_memory <= _size_load_queue))
+      test.error("Bypass number must be less than load_queue's size.");
+      test.error(_("Bypass number must be less than load_queue's size.\n"));
+    if (_nb_cache_port > 1)
+      test.warning(_("nb_cache_port > 1 is unsupported (Coming Soon).\n"));
+    if (_nb_inst_memory > 1)
+      test.warning(_("nb_inst_memory > 1 is unsupported (Coming Soon).\n"));
     log_printf(FUNC,Load_store_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/Makefile

r81	r88
24	24	library_clean : Read_queue_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/include/test.h

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h"
+#include "Common/include/Time.h"
 using namespace std;
 …
               morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue::Parameters * param);
-class Time
+{
-private : timeval time_begin;
-// private : timeval time_end;
-public  : Time ()
+  {
-    gettimeofday(&time_begin     ,NULL);
-  };
-public  : ~Time ()
+  {
-    cout << *this;
-  };
-public  : friend ostream& operator<< (ostream& output_stream,
-                                      const Time & x)
+  {
-    timeval time_end;
-    gettimeofday(&time_end       ,NULL);
-    uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
-    double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec);
-    output_stream << nb_cycles << "\t(" << average << " cycles / seconds )" << endl;
-    return output_stream;
+  }
-};

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/src/main.cpp

r81	r88
77	77	,size_store_queue
78	78	,size_load_queue
	79	,true //is_toplevel
79	80	);
80	81

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Read_queue * _Read_queue = new Read_queue (name.c_str(),
 #ifdef STATISTICS
 …
 #endif
                                              _param,
                                              USE_ALL);
+                                             _usage);
 #ifdef SYSTEMC
 …
   if(_param->_have_port_ooo_engine_id)
     (*(_Read_queue-> in_READ_QUEUE_IN_OOO_ENGINE_ID  )) (*(READ_QUEUE_IN_OOO_ENGINE_ID  ));
   if(_param->_have_port_rob_id       )
+  if(_param->_have_port_rob_ptr       )
     (*(_Read_queue-> in_READ_QUEUE_IN_ROB_ID         )) (*(READ_QUEUE_IN_ROB_ID         ));
   (*(_Read_queue-> in_READ_QUEUE_IN_OPERATION      )) (*(READ_QUEUE_IN_OPERATION      ));
 …
   if(_param->_have_port_ooo_engine_id)
     (*(_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) (*(READ_QUEUE_OUT_OOO_ENGINE_ID ));
   if(_param->_have_port_rob_id       )
+  if(_param->_have_port_rob_ptr       )
     (*(_Read_queue->out_READ_QUEUE_OUT_ROB_ID        )) (*(READ_QUEUE_OUT_ROB_ID        ));
   (*(_Read_queue->out_READ_QUEUE_OUT_OPERATION     )) (*(READ_QUEUE_OUT_OPERATION     ));
 …
               if(_param->_have_port_front_end_id )
                 READ_QUEUE_IN_FRONT_END_ID   ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
               if(_param->_have_port_rob_id       )
+              if(_param->_have_port_rob_ptr       )
                 READ_QUEUE_IN_ROB_ID      ->write(request_in);
               READ_QUEUE_IN_OPERATION   ->write(0);
 …
+            {
               Tpacket_t  rob_id;
               if(_param->_have_port_rob_id       )
+              if(_param->_have_port_rob_ptr       )
                 rob_id = READ_QUEUE_OUT_ROB_ID->read();
               else
 …
   TEST_OK ("End of Simulation");
   delete _time;
   cout << "<" << name << "> ............ Stop Simulation" << endl;
 …
    if(_param->_have_port_ooo_engine_id )
      delete    READ_QUEUE_IN_OOO_ENGINE_ID;
    if(_param->_have_port_rob_id       )
+   if(_param->_have_port_rob_ptr       )
      delete    READ_QUEUE_IN_ROB_ID    ;
    delete    READ_QUEUE_IN_OPERATION    ;
 …
    if(_param->_have_port_ooo_engine_id )
      delete    READ_QUEUE_OUT_OOO_ENGINE_ID;
    if(_param->_have_port_rob_id       )
+   if(_param->_have_port_rob_ptr       )
      delete    READ_QUEUE_OUT_ROB_ID      ;
    delete    READ_QUEUE_OUT_OPERATION   ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t    _size_queue           ;
   public : const uint32_t    _nb_context           ;
   public : const uint32_t    _nb_front_end         ;
   public : const uint32_t    _nb_ooo_engine        ;
   public : const uint32_t    _nb_packet            ;
   public : const uint32_t    _size_general_data    ;
   public : const uint32_t    _size_special_data    ;
   public : const uint32_t    _nb_general_register  ;
   public : const uint32_t    _nb_special_register  ;
   public : const uint32_t    _nb_gpr_write         ;
   public : const uint32_t    _nb_spr_write         ;
   public : const uint32_t    _size_store_queue     ;
   public : const uint32_t    _size_load_queue      ;
+  public : uint32_t    _size_queue           ;
+  public : uint32_t    _nb_context           ;
+  public : uint32_t    _nb_front_end         ;
+  public : uint32_t    _nb_ooo_engine        ;
+  public : uint32_t    _nb_packet            ;
+//public : uint32_t    _size_general_data    ;
+//public : uint32_t    _size_special_data    ;
+  public : uint32_t    _nb_general_register  ;
+  public : uint32_t    _nb_special_register  ;
+  public : uint32_t    _nb_gpr_write         ;
+  public : uint32_t    _nb_spr_write         ;
+//public : uint32_t    _size_store_queue     ;
+//public : uint32_t    _size_load_queue      ;
   public : const uint32_t    _nb_gpr_read          ;
   public : const uint32_t    _nb_spr_read          ;
   public : const uint32_t    _size_context_id      ;
   public : const uint32_t    _size_front_end_id    ;
   public : const uint32_t    _size_ooo_engine_id   ;
   public : const uint32_t    _size_rob_id          ;
   public : const uint32_t    _size_general_register;
   public : const uint32_t    _size_special_register;
+  public : uint32_t    _nb_gpr_read          ;
+  public : uint32_t    _nb_spr_read          ;
+//public : uint32_t    _size_context_id      ;
+//public : uint32_t    _size_front_end_id    ;
+//public : uint32_t    _size_ooo_engine_id   ;
+//public : uint32_t    _size_rob_id          ;
+//public : uint32_t    _size_general_register;
+//public : uint32_t    _size_special_register;
   public : const bool        _have_port_context_id   ;
   public : const bool        _have_port_front_end_id ;
   public : const bool        _have_port_ooo_engine_id;
   public : const bool        _have_port_rob_id       ;
   public : const bool        _have_port_load_queue_ptr;
+//public : bool        _have_port_context_id   ;
+//public : bool        _have_port_front_end_id ;
+//public : bool        _have_port_ooo_engine_id;
+//public : bool        _have_port_rob_id       ;
+//public : bool        _have_port_load_queue_ptr;
   public : const uint32_t    _size_internal_queue;
+  public : uint32_t    _size_internal_queue;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t nb_spr_write       ,
                         uint32_t size_store_queue   ,
+                        uint32_t size_load_queue    );
+                        uint32_t size_load_queue    ,
+                        bool     is_toplevel=false  );
+  public : Parameters  (Parameters & param) ;
+  public : ~Parameters () ;
+//public : Parameters  (Parameters & param) ;
+  public : ~Parameters (void) ;
+  public : void                 copy      (void);
   public : Parameters_test      msg_error (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Read_queue.h

-              r82
+              r88
 #include <iostream>
 #include <queue>
+#include <list>
 #include "Common/include/ToString.h"
 #include "Common/include/Debug.h"
 …
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   protected : Tread_queue_head_entry_t       * _queue_head;
   protected : std::queue<Tread_queue_entry_t *>   * _queue;
+  protected : std::list<Tread_queue_entry_t *>   * _queue;
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Parameters.cpp

-              r81
+              r88
                           uint32_t nb_spr_write       ,
                           uint32_t size_store_queue   ,
+                          uint32_t size_load_queue    ):
+    _size_queue            (size_queue           ),
+    _nb_context            (nb_context           ),
+    _nb_front_end          (nb_front_end         ),
+    _nb_ooo_engine         (nb_ooo_engine        ),
+    _nb_packet             (nb_packet            ),
+    _size_general_data     (size_general_data    ),
+    _size_special_data     (size_special_data    ),
+    _nb_general_register   (nb_general_register  ),
+    _nb_special_register   (nb_special_register  ),
+    _nb_gpr_write          (nb_gpr_write         ),
+    _nb_spr_write          (nb_spr_write         ),
+    _size_store_queue      (size_store_queue     ),
+    _size_load_queue       (size_load_queue      ),
+    _nb_gpr_read           (2                    ),
+    _nb_spr_read           (1                    ),
+    _size_context_id       (static_cast<uint32_t>(log2(_nb_context         ))),
+    _size_front_end_id     (static_cast<uint32_t>(log2(_nb_front_end       ))),
+    _size_ooo_engine_id    (static_cast<uint32_t>(log2(_nb_ooo_engine      ))),
+    _size_rob_id           (static_cast<uint32_t>(log2(_nb_packet          ))),
+    _size_general_register (static_cast<uint32_t>(log2(_nb_general_register))),
+    _size_special_register (static_cast<uint32_t>(log2(_nb_special_register))),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_rob_id        (_size_rob_id        > 0),
+    _have_port_load_queue_ptr(_size_load_queue    > 1),
+    _size_internal_queue     (  _size_context_id       //_context_id
+                              + _size_front_end_id     //_front_end_id
+                              + _size_ooo_engine_id    //_ooo_engine_id
+                              + _size_rob_id           //_rob_id
+                              + _size_operation        //_operation
+                              + _size_type             //_type
+                              + log2(_size_store_queue)//_store_queue_ptr_write
+                              + log2(_size_load_queue )//_load_queue_ptr_write
+                              + 1                      //_has_immediat
+                              + _size_general_data     //_immediat
+                              + 1                      //_read_ra
+                              + _size_general_register //_num_reg_ra
+                              + 1                      //_read_rb
+                              + _size_general_register //_num_reg_rb
+                              + 1                      //_read_rc
+                              + _size_special_register //_num_reg_rc
+                              + 1                      //_write_rd
+                              + _size_general_register //_num_reg_rd
+                              + 1                      //_write_re
+                              + _size_special_register //_num_reg_re
+                                )
+                          uint32_t size_load_queue    ,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Read_queue,"Parameters","Begin");
+    _size_queue              = size_queue           ;
+    _nb_context              = nb_context           ;
+    _nb_front_end            = nb_front_end         ;
+    _nb_ooo_engine           = nb_ooo_engine        ;
+    _nb_packet               = nb_packet            ;
+    _nb_general_register     = nb_general_register  ;
+    _nb_special_register     = nb_special_register  ;
+    _nb_gpr_write            = nb_gpr_write         ;
+    _nb_spr_write            = nb_spr_write         ;
+    _nb_gpr_read             = 2                    ;
+    _nb_spr_read             = 1                    ;
+    _size_internal_queue     = (  log2(nb_context         ) //_context_id
+                                + log2(nb_front_end       ) //_front_end_id
+                                + log2(nb_ooo_engine      ) //_ooo_engine_id
+                                + log2(nb_packet          ) //_rob_id
+                                + _size_operation           //_operation
+                                + _size_type                //_type
+                                + log2(size_store_queue   ) //_store_queue_ptr_write
+                                + log2(size_load_queue    ) //_load_queue_ptr_write
+                                + 1                         //_has_immediat
+                                +  size_general_data        //_immediat
+                                + 1                         //_read_ra
+                                + log2(nb_general_register) //_num_reg_ra
+                                + 1                         //_read_rb
+                                + log2(nb_general_register) //_num_reg_rb
+                                + 1                         //_read_rc
+                                + log2(nb_special_register) //_num_reg_rc
+                                + 1                         //_write_rd
+                                + log2(nb_general_register) //_num_reg_rd
+                                + 1                         //_write_re
+                                + log2(nb_special_register) //_num_reg_re
+                                );
     test();
+    if (is_toplevel)
+      {
+        _size_general_data       = size_general_data    ;
+        _size_special_data       = size_special_data    ;
+        _size_store_queue_ptr    = log2(size_store_queue);
+        _size_load_queue_ptr     = log2(size_load_queue );
+        _size_context_id         = log2(_nb_context         );
+        _size_front_end_id       = log2(_nb_front_end       );
+        _size_ooo_engine_id      = log2(_nb_ooo_engine      );
+        _size_rob_ptr            = log2(_nb_packet          );
+        _size_general_register   = log2(_nb_general_register);
+        _size_special_register   = log2(_nb_special_register);
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        _have_port_load_queue_ptr= _size_load_queue_ptr> 0;
+        copy();
+      }
     log_printf(FUNC,Read_queue,"Parameters","End");
   };
   Parameters::Parameters (Parameters & param):
     _size_queue            (param._size_queue            ),
     _nb_context            (param._nb_context            ),
     _nb_front_end          (param._nb_front_end          ),
     _nb_ooo_engine         (param._nb_ooo_engine         ),
     _nb_packet             (param._nb_packet             ),
     _size_general_data     (param._size_general_data     ),
     _size_special_data     (param._size_special_data     ),
     _nb_general_register   (param._nb_general_register   ),
     _nb_special_register   (param._nb_special_register   ),
     _nb_gpr_write          (param._nb_gpr_write          ),
     _nb_spr_write          (param._nb_spr_write          ),
     _size_store_queue      (param._size_store_queue      ),
     _size_load_queue       (param._size_load_queue       ),
+//   Parameters::Parameters (Parameters & param):
+//     _size_queue            (param._size_queue            ),
+//     _nb_context            (param._nb_context            ),
+//     _nb_front_end          (param._nb_front_end          ),
+//     _nb_ooo_engine         (param._nb_ooo_engine         ),
+//     _nb_packet             (param._nb_packet             ),
+//     _size_general_data     (param._size_general_data     ),
+//     _size_special_data     (param._size_special_data     ),
+//     _nb_general_register   (param._nb_general_register   ),
+//     _nb_special_register   (param._nb_special_register   ),
+//     _nb_gpr_write          (param._nb_gpr_write          ),
+//     _nb_spr_write          (param._nb_spr_write          ),
+//     _size_store_queue      (param._size_store_queue      ),
+//     _size_load_queue       (param._size_load_queue       ),
     _nb_gpr_read           (param._nb_gpr_read           ),
     _nb_spr_read           (param._nb_spr_read           ),
     _size_context_id       (param._size_context_id       ),
     _size_front_end_id     (param._size_front_end_id     ),
     _size_ooo_engine_id    (param._size_ooo_engine_id    ),
     _size_rob_id           (param._size_rob_id           ),
     _size_general_register (param._size_general_register ),
     _size_special_register (param._size_special_register ),
+//     _nb_gpr_read           (param._nb_gpr_read           ),
+//     _nb_spr_read           (param._nb_spr_read           ),
+//     _size_context_id       (param._size_context_id       ),
+//     _size_front_end_id     (param._size_front_end_id     ),
+//     _size_ooo_engine_id    (param._size_ooo_engine_id    ),
+//     _size_rob_id           (param._size_rob_id           ),
+//     _size_general_register (param._size_general_register ),
+//     _size_special_register (param._size_special_register ),
     _have_port_context_id    (param._have_port_context_id   ),
     _have_port_front_end_id  (param._have_port_front_end_id ),
     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
     _have_port_rob_id        (param._have_port_rob_id       ),
     _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
+//     _have_port_context_id    (param._have_port_context_id   ),
+//     _have_port_front_end_id  (param._have_port_front_end_id ),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+//     _have_port_rob_id        (param._have_port_rob_id       ),
+//     _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
     _size_internal_queue     (param._size_internal_queue    )
+  {
     log_printf(FUNC,Read_queue,"Parameters (copy)","Begin");
     test();
     log_printf(FUNC,Read_queue,"Parameters (copy)","End");
   };
+//     _size_internal_queue     (param._size_internal_queue    )
+//   {
+//     log_printf(FUNC,Read_queue,"Parameters (copy)","Begin");
+//     test();
+//     log_printf(FUNC,Read_queue,"Parameters (copy)","End");
+//   };
   Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Read_queue,"~Parameters","Begin");
     log_printf(FUNC,Read_queue,"~Parameters","End");
+  };
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Read_queue,"copy","Begin");
+    log_printf(FUNC,Read_queue,"copy","End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Parameters_print.cpp

-              r81
+              r88
     xml.singleton_begin("nb_ooo_engine      "); xml.attribut("value",toString(_nb_ooo_engine      )); xml.singleton_end();
     xml.singleton_begin("nb_packet          "); xml.attribut("value",toString(_nb_packet          )); xml.singleton_end();
     xml.singleton_begin("size_general_data  "); xml.attribut("value",toString(_size_general_data  )); xml.singleton_end();
     xml.singleton_begin("size_special_data  "); xml.attribut("value",toString(_size_special_data  )); xml.singleton_end();
+//  xml.singleton_begin("size_general_data  "); xml.attribut("value",toString(_size_general_data  )); xml.singleton_end();
+//  xml.singleton_begin("size_special_data  "); xml.attribut("value",toString(_size_special_data  )); xml.singleton_end();
     xml.singleton_begin("nb_general_register"); xml.attribut("value",toString(_nb_general_register)); xml.singleton_end();
     xml.singleton_begin("nb_special_register"); xml.attribut("value",toString(_nb_special_register)); xml.singleton_end();
     xml.singleton_begin("nb_gpr_write       "); xml.attribut("value",toString(_nb_gpr_write       )); xml.singleton_end();
     xml.singleton_begin("nb_spr_write       "); xml.attribut("value",toString(_nb_spr_write       )); xml.singleton_end();
     xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
     xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
+//  xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
+//  xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
     xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue.cpp

-              r82
+              r88
     log_printf(FUNC,Read_queue,"Read_queue","Begin");
+#if DEBUG_Read_queue == true
+    log_printf(INFO,Read_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
 #ifdef SYSTEMC
     log_printf(INFO,Read_queue,"Read_queue","Allocation");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Read_queue,FUNCTION,"Allocation of statistics");
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Read_queue,FUNCTION,"Allocation of statistics");
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,Read_queue,"Read_queue","Generate the vhdl");
+    vhdl();
+#endif
+#ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,Read_queue,"Read_queue","Generate the vhdl");
+        vhdl();
+      }
+#endif
+#ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     log_printf(INFO,Read_queue,"Read_queue","Method - transition");
 …
+      }
 #endif
+      }
 #endif
     log_printf(FUNC,Read_queue,"Read_queue","End");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Read_queue,"~Read_queue","Generate Statistics file");
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Read_queue,"~Read_queue","Generate Statistics file");
+        delete _stat;
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_allocation.cpp

-              r82
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
 …
      in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
+    }
     // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       Interface_fifo * interface = _interfaces->set_interface("read_queue_in"
 …
        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_id      )
        in_READ_QUEUE_IN_ROB_ID         = interface->set_signal_in  <Tpacket_t         > ("rob_id"      ,_param->_size_rob_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", log2(_param->_size_store_queue));
+       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" , log2(_param->_size_load_queue ));
+       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     );
 …
+     }
     // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       Interface_fifo * interface = _interfaces->set_interface("read_queue_out"
 …
       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_id      )
         out_READ_QUEUE_OUT_ROB_ID         = interface->set_signal_out <Tpacket_t         > ("rob_id"      ,_param->_size_rob_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", log2(_param->_size_store_queue));
+      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" , log2(_param->_size_load_queue ));
+      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     );
 …
+     }
     // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     out_GPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_gpr_read];
 …
+      }
     // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     out_SPR_READ_VAL          = new SC_OUT(Tcontrol_t        ) * [_param->_nb_spr_read];
 …
+      }
     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
 …
+      }
     // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
 …
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     _queue      = new std::queue<Tread_queue_entry_t *>;
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    _queue      = new std::list<Tread_queue_entry_t *>;
     _queue_head = new Tread_queue_head_entry_t;
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_deallocation.cpp

-              r81
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     log_printf(FUNC,Read_queue,"deallocation","Begin");
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete     in_CLOCK ;
     delete     in_NRESET;
     // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete     in_READ_QUEUE_IN_VAL            ;
     delete    out_READ_QUEUE_IN_ACK            ;
 …
     if(_param->_have_port_ooo_engine_id)
       delete     in_READ_QUEUE_IN_OOO_ENGINE_ID  ;
     if(_param->_have_port_rob_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_NUM_REG_RE     ;
     // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete    out_READ_QUEUE_OUT_VAL            ;
     delete     in_READ_QUEUE_OUT_ACK            ;
 …
     if(_param->_have_port_ooo_engine_id)
       delete    out_READ_QUEUE_OUT_OOO_ENGINE_ID  ;
     if(_param->_have_port_rob_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_NUM_REG_RE     ;
     // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete [] out_GPR_READ_VAL       ;
 …
     delete []  in_GPR_READ_DATA_VAL  ;
     // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete [] out_SPR_READ_VAL       ;
 …
     delete []  in_SPR_READ_DATA_VAL  ;
     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete []  in_GPR_WRITE_VAL       ;
 …
     delete []  in_GPR_WRITE_DATA      ;
     // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete []  in_SPR_WRITE_VAL       ;
 …
     delete []  in_SPR_WRITE_NUM_REG   ;
     delete []  in_SPR_WRITE_DATA      ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     while (_queue->empty() == false)
+      {
         delete _queue->front();
         _queue->pop();
+        _queue->pop_front();
+      }
     delete _queue;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMealy_read_queue_out_gpr.cpp

-              r81
+              r88
   void Read_queue::genMealy_read_queue_out_gpr (void)
+  {
+    log_printf(FUNC,Read_queue,FUNCTION,"Begin");
+    log_begin(Read_queue,FUNCTION);
+    log_function(Read_queue,FUNCTION,_name.c_str());
     internal_READ_QUEUE_OUT_DATA_RA_VAL = (// Previous value
 …
                                            );
     log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RA_VAL   : %d",internal_READ_QUEUE_OUT_DATA_RA_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue_head->_data_ra_val           : %d",_queue_head->_data_ra_val);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue_head->_read_ra_val           : %d",_queue_head->_read_ra_val);
     log_printf(TRACE,Read_queue,FUNCTION,"   * in_GPR_READ_ACK      [0]            : %d",PORT_READ(in_GPR_READ_ACK      [0]));
     log_printf(TRACE,Read_queue,FUNCTION,"   * in_GPR_READ_DATA_VAL [0]            : %d",PORT_READ(in_GPR_READ_DATA_VAL [0]));
+    log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_DATA_RA_VAL   : %d",internal_READ_QUEUE_OUT_DATA_RA_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue_head->_data_ra_val           : %d",_queue_head->_data_ra_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue_head->_read_ra_val           : %d",_queue_head->_read_ra_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * in_GPR_READ_ACK      [0]            : %d",PORT_READ(in_GPR_READ_ACK      [0]));
+    log_printf(TRACE,Read_queue,FUNCTION,"    * in_GPR_READ_DATA_VAL [0]            : %d",PORT_READ(in_GPR_READ_DATA_VAL [0]));
     internal_READ_QUEUE_OUT_DATA_RB_VAL = (_queue_head->_data_rb_val or
 …
                                            );
     log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RB_VAL   : %d",internal_READ_QUEUE_OUT_DATA_RB_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue_head->_data_rb_val           : %d",_queue_head->_data_rb_val);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue_head->_read_rb_val           : %d",_queue_head->_read_rb_val);
     log_printf(TRACE,Read_queue,FUNCTION,"   * in_GPR_READ_ACK      [1]            : %d",PORT_READ(in_GPR_READ_ACK      [1]));
     log_printf(TRACE,Read_queue,FUNCTION,"   * in_GPR_READ_DATA_VAL [1]            : %d",PORT_READ(in_GPR_READ_DATA_VAL [1]));
+    log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_DATA_RB_VAL   : %d",internal_READ_QUEUE_OUT_DATA_RB_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue_head->_data_rb_val           : %d",_queue_head->_data_rb_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue_head->_read_rb_val           : %d",_queue_head->_read_rb_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * in_GPR_READ_ACK      [1]            : %d",PORT_READ(in_GPR_READ_ACK      [1]));
+    log_printf(TRACE,Read_queue,FUNCTION,"    * in_GPR_READ_DATA_VAL [1]            : %d",PORT_READ(in_GPR_READ_DATA_VAL [1]));
 …
             if (_queue_head->_num_reg_ra == gpr_write_num_reg)
+              {
                 log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RA_VAL   - bypass hit (%d)",i);
+                log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_DATA_RA_VAL   - bypass hit (%d)",i);
                 internal_READ_QUEUE_OUT_DATA_RA_VAL = 1;
 …
             if (_queue_head->_num_reg_rb == gpr_write_num_reg)
+              {
                 log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RB_VAL   - bypass hit (%d)",i);
+                log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_DATA_RB_VAL   - bypass hit (%d)",i);
                 internal_READ_QUEUE_OUT_DATA_RB_VAL = 1;
 #ifdef SYSTEMC_VHDL_COMPATIBILITY
 …
     PORT_WRITE(out_READ_QUEUE_OUT_DATA_RB    ,internal_READ_QUEUE_OUT_DATA_RB    );
     log_printf(FUNC,Read_queue,FUNCTION,"End");
+    log_end(Read_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMealy_read_queue_out_spr.cpp

-              r81
+              r88
   void Read_queue::genMealy_read_queue_out_spr (void)
+  {
+    log_printf(FUNC,Read_queue,FUNCTION,"Begin");
+    log_begin(Read_queue,FUNCTION);
+    log_function(Read_queue,FUNCTION,_name.c_str());
     internal_READ_QUEUE_OUT_DATA_RC_VAL = (// Previous value
 …
                                            );
     log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RC_VAL   : %d",internal_READ_QUEUE_OUT_DATA_RC_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue_head->_data_rc_val           : %d",_queue_head->_data_rc_val);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue_head->_read_rc_val           : %d",_queue_head->_read_rc_val);
     log_printf(TRACE,Read_queue,FUNCTION,"   * in_SPR_READ_ACK      [0]            : %d",PORT_READ(in_SPR_READ_ACK      [0]));
     log_printf(TRACE,Read_queue,FUNCTION,"   * in_SPR_READ_DATA_VAL [0]            : %d",PORT_READ(in_SPR_READ_DATA_VAL [0]));
+    log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_DATA_RC_VAL   : %d",internal_READ_QUEUE_OUT_DATA_RC_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue_head->_data_rc_val           : %d",_queue_head->_data_rc_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue_head->_read_rc_val           : %d",_queue_head->_read_rc_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * in_SPR_READ_ACK      [0]            : %d",PORT_READ(in_SPR_READ_ACK      [0]));
+    log_printf(TRACE,Read_queue,FUNCTION,"    * in_SPR_READ_DATA_VAL [0]            : %d",PORT_READ(in_SPR_READ_DATA_VAL [0]));
     internal_READ_QUEUE_OUT_DATA_RC     = (// Test if have an previous access
 …
             if (_queue_head->_num_reg_rc == PORT_READ(in_SPR_WRITE_NUM_REG [i]))
+              {
                 log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_DATA_RC_VAL   - bypass hit (%d)",i);
+                log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_DATA_RC_VAL   - bypass hit (%d)",i);
                 internal_READ_QUEUE_OUT_DATA_RC_VAL = 1;
 #ifdef SYSTEMC_VHDL_COMPATIBILITY
 …
     PORT_WRITE(out_READ_QUEUE_OUT_DATA_RC    ,internal_READ_QUEUE_OUT_DATA_RC    );
     log_printf(FUNC,Read_queue,FUNCTION,"End");
+    log_end(Read_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMealy_read_queue_out_val.cpp

-              r81
+              r88
   void Read_queue::genMealy_read_queue_out_val (void)
+  {
+    log_printf(FUNC,Read_queue,FUNCTION,"Begin");
+    log_begin(Read_queue,FUNCTION);
+    log_function(Read_queue,FUNCTION,_name.c_str());
     internal_READ_QUEUE_OUT_READ_RA_VAL = (// Previous value
 …
     PORT_WRITE(out_READ_QUEUE_OUT_VAL, internal_READ_QUEUE_OUT_VAL);
     log_printf(TRACE,Read_queue,FUNCTION," * internal_READ_QUEUE_OUT_VAL           : %d",internal_READ_QUEUE_OUT_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"   * _queue->empty()                     : %d",_queue->empty());
     log_printf(TRACE,Read_queue,FUNCTION,"   * internal_READ_QUEUE_OUT_READ_RA_VAL : %d",internal_READ_QUEUE_OUT_READ_RA_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"     * _queue_head->_read_ra_val         : %d",_queue_head->_read_ra_val);
     log_printf(TRACE,Read_queue,FUNCTION,"     * in_GPR_READ_ACK      [0]          : %d",PORT_READ(in_GPR_READ_ACK      [0]));
     log_printf(TRACE,Read_queue,FUNCTION,"   * internal_READ_QUEUE_OUT_READ_RB_VAL : %d",internal_READ_QUEUE_OUT_READ_RB_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"     * _queue_head->_read_rb_val         : %d",_queue_head->_read_rb_val);
     log_printf(TRACE,Read_queue,FUNCTION,"     * in_GPR_READ_ACK      [1]          : %d",PORT_READ(in_GPR_READ_ACK      [1]));
     log_printf(TRACE,Read_queue,FUNCTION,"   * internal_READ_QUEUE_OUT_READ_RC_VAL : %d",internal_READ_QUEUE_OUT_READ_RC_VAL);
     log_printf(TRACE,Read_queue,FUNCTION,"     * _queue_head->_read_rc_val         : %d",_queue_head->_read_rc_val);
     log_printf(TRACE,Read_queue,FUNCTION,"     * in_SPR_READ_ACK      [0]          : %d",PORT_READ(in_SPR_READ_ACK      [0]));
+    log_printf(TRACE,Read_queue,FUNCTION,"  * internal_READ_QUEUE_OUT_VAL           : %d",internal_READ_QUEUE_OUT_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"    * _queue->empty()                     : %d",_queue->empty());
+    log_printf(TRACE,Read_queue,FUNCTION,"    * internal_READ_QUEUE_OUT_READ_RA_VAL : %d",internal_READ_QUEUE_OUT_READ_RA_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"      * _queue_head->_read_ra_val         : %d",_queue_head->_read_ra_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"      * in_GPR_READ_ACK      [0]          : %d",PORT_READ(in_GPR_READ_ACK      [0]));
+    log_printf(TRACE,Read_queue,FUNCTION,"    * internal_READ_QUEUE_OUT_READ_RB_VAL : %d",internal_READ_QUEUE_OUT_READ_RB_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"      * _queue_head->_read_rb_val         : %d",_queue_head->_read_rb_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"      * in_GPR_READ_ACK      [1]          : %d",PORT_READ(in_GPR_READ_ACK      [1]));
+    log_printf(TRACE,Read_queue,FUNCTION,"    * internal_READ_QUEUE_OUT_READ_RC_VAL : %d",internal_READ_QUEUE_OUT_READ_RC_VAL);
+    log_printf(TRACE,Read_queue,FUNCTION,"      * _queue_head->_read_rc_val         : %d",_queue_head->_read_rc_val);
+    log_printf(TRACE,Read_queue,FUNCTION,"      * in_SPR_READ_ACK      [0]          : %d",PORT_READ(in_SPR_READ_ACK      [0]));
     log_printf(FUNC,Read_queue,FUNCTION,"End");
+    log_end(Read_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_genMoore.cpp

-              r81
+              r88
   void Read_queue::genMoore (void)
+  {
+    log_printf(FUNC,Read_queue,FUNCTION,"Begin");
+    log_begin(Read_queue,FUNCTION);
+    log_function(Read_queue,FUNCTION,_name.c_str());
     bool not_full  = not (_queue->size() == _param->_size_queue);
 …
     if(_param->_have_port_ooo_engine_id)
       PORT_WRITE (out_READ_QUEUE_OUT_OOO_ENGINE_ID, _queue_head->_ooo_engine_id);
     if(_param->_have_port_rob_id       )
+    if(_param->_have_port_rob_ptr      )
       PORT_WRITE (out_READ_QUEUE_OUT_ROB_ID      , _queue_head->_rob_id      );
     PORT_WRITE (out_READ_QUEUE_OUT_OPERATION   , _queue_head->_operation   );
 …
     PORT_WRITE (out_SPR_READ_VAL           [0], not_empty and _queue_head->_read_rc_val);
     if(_param->_have_port_ooo_engine_id)
       PORT_WRITE (out_SPR_READ_OOO_ENGINE_ID [0],               _queue_head->_ooo_engine_id);
+    PORT_WRITE (out_SPR_READ_OOO_ENGINE_ID [0],               _queue_head->_ooo_engine_id);
     PORT_WRITE (out_SPR_READ_NUM_REG       [0],               _queue_head->_num_reg_rc);
     log_printf(FUNC,Read_queue,FUNCTION,"End");
+    log_end(Read_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/src/Read_queue_transition.cpp

-              r81
+              r88
   void Read_queue::transition (void)
+  {
+    log_printf(FUNC,Read_queue,FUNCTION,"Begin");
+    log_begin(Read_queue,FUNCTION);
+    log_function(Read_queue,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
         // > 2) flush all slot in one cycle
+        while (_queue->empty() == false)
+          _queue->pop();
+        _queue->clear();
+        // Init, else error in registerfile
+        _queue_head->_ooo_engine_id = 0;
+      }
     else
 …
 //        cout << (*_queue_head) << endl;
         log_printf(TRACE,Read_queue,FUNCTION,"Read_queue size (begin) : %d",_queue->size());
+        log_printf(TRACE,Read_queue,FUNCTION,"  * Read_queue size (begin) : %d",(int)_queue->size());
         // Write to read_queue
 …
         bool need_new_head = false;
         log_printf(TRACE,Read_queue,FUNCTION," * test transaction READ_QUEUE_IN  : %d,%d",PORT_READ(in_READ_QUEUE_IN_VAL), not_full);
+        log_printf(TRACE,Read_queue,FUNCTION,"    * test transaction READ_QUEUE_IN  : %d,%d",PORT_READ(in_READ_QUEUE_IN_VAL), not_full);
         if ((PORT_READ(in_READ_QUEUE_IN_VAL) == 1) and not_full)
+          {
 …
             if(_param->_have_port_ooo_engine_id)
               entry->_ooo_engine_id= PORT_READ(in_READ_QUEUE_IN_OOO_ENGINE_ID);
             if(_param->_have_port_rob_id       )
+            if(_param->_have_port_rob_ptr      )
               entry->_rob_id       = PORT_READ(in_READ_QUEUE_IN_ROB_ID      );
             entry->_operation    = PORT_READ(in_READ_QUEUE_IN_OPERATION   );
 …
             entry->_num_reg_re   = PORT_READ(in_READ_QUEUE_IN_NUM_REG_RE  );
+            log_printf(TRACE,Read_queue,FUNCTION,"   * push (id : %d-%d)",entry->_context_id, entry->_rob_id);
+            _queue->push(entry);
+            log_printf(TRACE,Read_queue,FUNCTION,"    * push (id : %d-%d)",entry->_context_id, entry->_rob_id);
+            _queue->push_back(entry);
             // read next new head
             if (empty)
+              {
                 log_printf(TRACE,Read_queue,FUNCTION,"     * queue was    empty");
+                log_printf(TRACE,Read_queue,FUNCTION,"    * queue was    empty");
                 need_new_head = true;
+              }
 …
         // Read from read_queue
         log_printf(TRACE,Read_queue,FUNCTION," * test transaction READ_QUEUE_OUT : %d,%d",internal_READ_QUEUE_OUT_VAL, PORT_READ(in_READ_QUEUE_OUT_ACK));
+        log_printf(TRACE,Read_queue,FUNCTION,"  * test transaction READ_QUEUE_OUT : %d,%d",internal_READ_QUEUE_OUT_VAL, PORT_READ(in_READ_QUEUE_OUT_ACK));
         if ((    internal_READ_QUEUE_OUT_VAL  == 1) and
             (PORT_READ(in_READ_QUEUE_OUT_ACK) == 1))
+          {
             // Pop the entry
             log_printf(TRACE,Read_queue,FUNCTION,"   * pop  (id : %d-%d)",_queue->front()->_context_id, _queue->front()->_rob_id);
             _queue->pop();
+            log_printf(TRACE,Read_queue,FUNCTION,"    * pop  (id : %d-%d)",_queue->front()->_context_id, _queue->front()->_rob_id);
+            _queue->pop_front();
             // read next new head
             if (_queue->empty() == false)
+              {
                 log_printf(TRACE,Read_queue,FUNCTION,"     * queue was not empty");
+                log_printf(TRACE,Read_queue,FUNCTION,"    * queue was not empty");
                 need_new_head = true;
+              }
 …
         if (need_new_head == true)
+          {
             log_printf(TRACE,Read_queue,FUNCTION," * new head");
+            log_printf(TRACE,Read_queue,FUNCTION,"  * new head");
             (*_queue_head) = (*_queue->front());
+          }
 …
 //        cout << (*_queue_head) << endl;
+        log_printf(TRACE,Read_queue,FUNCTION,"Read_queue size (end  ) : %d",_queue->size());
+#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Read_queue == true)
+        log_printf(TRACE,Read_queue,FUNCTION,"  * Dump Read_queue");
+        log_printf(TRACE,Read_queue,FUNCTION,"    * size : %d",(int)_queue->size());
+        if (_queue->size()>0)
+          {
+//   protected : Tread_queue_head_entry_t       * _queue_head;
+//   protected : std::queue<Tread_queue_entry_t *>   * _queue;
+            log_printf(TRACE,Read_queue,FUNCTION,"    * [%.4d] %.2d %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.1d %.1d %.4d %.1d %.8x, %.1d %.1d %.4d %.1d %.8x, %.1d %.1d %.4d %.1d %.2x, %.1d %.4d, %.1d %.4d (%s)",
+,
+                       _queue_head->_context_id           ,
+                       _queue_head->_front_end_id         ,
+                       _queue_head->_ooo_engine_id        ,
+                       _queue_head->_rob_id               ,
+                       _queue_head->_type                 ,
+                       _queue_head->_operation            ,
+                       _queue_head->_store_queue_ptr_write,
+                       _queue_head->_load_queue_ptr_write ,
+                       _queue_head->_has_immediat         ,
+                       _queue_head->_immediat             ,
+                       _queue_head->_read_ra              ,
+                       _queue_head->_read_ra_val          ,
+                       _queue_head->_num_reg_ra           ,
+                       _queue_head->_data_ra_val          ,
+                       _queue_head->_data_ra              ,
+                       _queue_head->_read_rb              ,
+                       _queue_head->_read_rb_val          ,
+                       _queue_head->_num_reg_rb           ,
+                       _queue_head->_data_rb_val          ,
+                       _queue_head->_data_rb              ,
+                       _queue_head->_read_rc              ,
+                       _queue_head->_read_rc_val          ,
+                       _queue_head->_num_reg_rc           ,
+                       _queue_head->_data_rc_val          ,
+                       _queue_head->_data_rc              ,
+                       _queue_head->_write_rd             ,
+                       _queue_head->_num_reg_rd           ,
+                       _queue_head->_write_re             ,
+                       _queue_head->_num_reg_re           ,
+                       toString_type(_queue_head->_type).c_str());
+            std::list<Tread_queue_entry_t *>::iterator it=_queue->begin();
+            ++it; // first is already printed
+            uint32_t i=1;
+            for (;it!=_queue->end(); ++it)
+              {
+                log_printf(TRACE,Read_queue,FUNCTION,"    * [%.4d] %.2d %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.1d   %.4d           , %.1d   %.4d           , %.1d   %.4d     , %.1d %.4d, %.1d %.4d (%s)",
+                           i,
+                           (*it)->_context_id           ,
+                           (*it)->_front_end_id         ,
+                           (*it)->_ooo_engine_id        ,
+                           (*it)->_rob_id               ,
+                           (*it)->_type                 ,
+                           (*it)->_operation            ,
+                           (*it)->_store_queue_ptr_write,
+                           (*it)->_load_queue_ptr_write ,
+                           (*it)->_has_immediat         ,
+                           (*it)->_immediat             ,
+                           (*it)->_read_ra              ,
+//                         (*it)->_read_ra_val          ,
+                           (*it)->_num_reg_ra           ,
+//                         (*it)->_data_ra_val          ,
+//                         (*it)->_data_ra              ,
+                           (*it)->_read_rb              ,
+//                         (*it)->_read_rb_val          ,
+                           (*it)->_num_reg_rb           ,
+//                         (*it)->_data_rb_val          ,
+//                         (*it)->_data_rb              ,
+                           (*it)->_read_rc              ,
+//                         (*it)->_read_rc_val          ,
+                           (*it)->_num_reg_rc           ,
+//                         (*it)->_data_rc_val          ,
+//                         (*it)->_data_rc              ,
+                           (*it)->_write_rd             ,
+                           (*it)->_num_reg_rd           ,
+                           (*it)->_write_re             ,
+                           (*it)->_num_reg_re           ,
+                           toString_type((*it)->_type).c_str());
+                ++i;
+              }
+          }
+#endif
+      }
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     end_cycle ();
+        end_cycle ();
 #endif
     log_printf(FUNC,Read_queue,FUNCTION,"End");
+    log_end(Read_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/Makefile

r81	r88
24	24	library_clean : Reservation_station_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/include/test.h

-              r81
+              r88
 #include <sys/time.h>
+#include "Common/include/Time.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Reservation_station.h"
 …
               morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::reservation_station::Parameters * param);
-class Time
+{
-private : timeval time_begin;
-// private : timeval time_end;
-public  : Time ()
+  {
-    gettimeofday(&time_begin     ,NULL);
-  };
-public  : ~Time ()
+  {
-    cout << *this;
-  };
-public  : friend ostream& operator<< (ostream& output_stream,
-                                      const Time & x)
+  {
-    timeval time_end;
-    gettimeofday(&time_end       ,NULL);
-    uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
-    double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec);
-    output_stream << nb_cycles << "\t(" << average << " cycles / seconds )" << endl;
-    return output_stream;
+  }
-};

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/main.cpp

r81	r88
86	86	,size_store_queue
87	87	,size_load_queue
	88	,true //is_toplevel
88	89	);
89	90

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Reservation_station * _Reservation_station = new Reservation_station
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   if (_param->_have_port_ooo_engine_id)
   (*(_Reservation_station-> in_INSERT_OOO_ENGINE_ID    )) (*( in_INSERT_OOO_ENGINE_ID    ));
   if (_param->_have_port_rob_id)
+  if (_param->_have_port_rob_ptr)
   (*(_Reservation_station-> in_INSERT_ROB_ID           )) (*( in_INSERT_ROB_ID           ));
   (*(_Reservation_station-> in_INSERT_OPERATION        )) (*( in_INSERT_OPERATION        ));
 …
   if (_param->_have_port_ooo_engine_id)
   (*(_Reservation_station->out_RETIRE_OOO_ENGINE_ID  [i])) (*(out_RETIRE_OOO_ENGINE_ID  [i]));
   if (_param->_have_port_rob_id)
+  if (_param->_have_port_rob_ptr)
   (*(_Reservation_station->out_RETIRE_ROB_ID         [i])) (*(out_RETIRE_ROB_ID         [i]));
   (*(_Reservation_station->out_RETIRE_OPERATION      [i])) (*(out_RETIRE_OPERATION      [i]));
 …
               if (_param->_have_port_ooo_engine_id)
               in_INSERT_OOO_ENGINE_ID  ->write(insert_ooo_engine_id);
               if (_param->_have_port_rob_id)
+              if (_param->_have_port_rob_ptr)
               in_INSERT_ROB_ID      ->write(request_in);
               in_INSERT_OPERATION   ->write(0);
 …
+                {
                   Tpacket_t  rob_id;
                   if (_param->_have_port_rob_id)
+                  if (_param->_have_port_rob_ptr)
                     rob_id = out_RETIRE_ROB_ID [i]->read();
                   else
 …
   if (_param->_have_port_ooo_engine_id)
   delete     in_INSERT_OOO_ENGINE_ID  ;
   if (_param->_have_port_rob_id)
+  if (_param->_have_port_rob_ptr)
   delete     in_INSERT_ROB_ID      ;
   delete     in_INSERT_OPERATION   ;
 …
   if (_param->_have_port_ooo_engine_id)
   delete [] out_RETIRE_OOO_ENGINE_ID  ;
   if (_param->_have_port_rob_id)
+  if (_param->_have_port_rob_ptr)
   delete [] out_RETIRE_ROB_ID   ;
   delete [] out_RETIRE_OPERATION   ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
+  public : const uint32_t    _size_queue           ;
+  public : const uint32_t    _nb_inst_retire       ;
+  public : const uint32_t    _nb_context           ;
+  public : const uint32_t    _nb_front_end         ;
+  public : const uint32_t    _nb_ooo_engine        ;
+  public : const uint32_t    _nb_packet            ;
+  public : const uint32_t    _size_general_data    ;
+  public : const uint32_t    _size_special_data    ;
+  public : const uint32_t    _nb_general_register  ;
+  public : const uint32_t    _nb_special_register  ;
+  public : const uint32_t    _nb_gpr_write         ;
+  public : const uint32_t    _nb_spr_write         ;
+  public : const uint32_t    _nb_bypass_write      ;//if nb_bypass=0, then bypass is desactivated
+  public : const uint32_t    _nb_bypass_memory     ;//if nb_bypass=0, then bypass is desactivated
+  public : const uint32_t    _size_store_queue     ;
+  public : const uint32_t    _size_load_queue      ;
+  public : uint32_t    _size_queue           ;
+  public : uint32_t    _nb_inst_retire       ;
+  public : uint32_t    _nb_context           ;
+  public : uint32_t    _nb_front_end         ;
+  public : uint32_t    _nb_ooo_engine        ;
+  public : uint32_t    _nb_packet            ;
+//public : uint32_t    _size_general_data    ;
+//public : uint32_t    _size_special_data    ;
+  public : uint32_t    _nb_general_register  ;
+  public : uint32_t    _nb_special_register  ;
+  public : uint32_t    _nb_gpr_write         ;
+  public : uint32_t    _nb_spr_write         ;
+  public : uint32_t    _nb_bypass_write      ;//if nb_bypass=0, then bypass is desactivated
+  public : uint32_t    _nb_bypass_memory     ;//if nb_bypass=0, then bypass is desactivated
+//public : uint32_t    _size_store_queue     ;
+//public : uint32_t    _size_load_queue      ;
+    /*
+  public : bool        _have_immediat        ;
+  public : bool        _have_gpr_ra          ;
+  public : bool        _have_gpr_rb          ;
+  public : bool        _have_spr_rc          ;
+  public : bool        _have_gpr_rd          ;
+  public : bool        _have_spr_re          ;
+    */
+//public : uint32_t    _size_context_id      ;
+//public : uint32_t    _size_front_end_id    ;
+//public : uint32_t    _size_ooo_engine_id   ;
+//public : uint32_t    _size_rob_ptr         ;
+//public : uint32_t    _size_general_register;
+//public : uint32_t    _size_special_register;
+    /*
+  public : const bool        _have_immediat        ;
+  public : const bool        _have_gpr_ra          ;
+  public : const bool        _have_gpr_rb          ;
+  public : const bool        _have_spr_rc          ;
+  public : const bool        _have_gpr_rd          ;
+  public : const bool        _have_spr_re          ;
+    */
+  public : const uint32_t    _size_context_id      ;
+  public : const uint32_t    _size_front_end_id    ;
+  public : const uint32_t    _size_ooo_engine_id   ;
+  public : const uint32_t    _size_rob_id          ;
+  public : const uint32_t    _size_general_register;
+  public : const uint32_t    _size_special_register;
+  public : const bool        _have_port_context_id   ;
+  public : const bool        _have_port_front_end_id ;
+  public : const bool        _have_port_ooo_engine_id;
+  public : const bool        _have_port_rob_id       ;
+  public : const bool        _have_port_load_queue_ptr;
+//public : bool        _have_port_context_id   ;
+//public : bool        _have_port_front_end_id ;
+//public : bool        _have_port_ooo_engine_id;
+//public : bool        _have_port_rob_ptr      ;
+//public : bool        _have_port_load_queue_ptr;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t nb_bypass_memory   ,
                         uint32_t size_store_queue   ,
+                        uint32_t size_load_queue    );
+                        uint32_t size_load_queue    ,
+                        bool     is_toplevel=false);
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Parameters.cpp

-              r81
+              r88
                           uint32_t nb_bypass_memory   ,
                           uint32_t size_store_queue   ,
+                          uint32_t size_load_queue    ):
+    _size_queue            (size_queue           ),
+    _nb_inst_retire        (nb_inst_retire       ),
+    _nb_context            (nb_context           ),
+    _nb_front_end          (nb_front_end         ),
+    _nb_ooo_engine         (nb_ooo_engine        ),
+    _nb_packet             (nb_packet            ),
+    _size_general_data     (size_general_data    ),
+    _size_special_data     (size_special_data    ),
+    _nb_general_register   (nb_general_register  ),
+    _nb_special_register   (nb_special_register  ),
+    _nb_gpr_write          (nb_gpr_write         ),
+    _nb_spr_write          (nb_spr_write         ),
+    _nb_bypass_write       (nb_bypass_write      ),
+    _nb_bypass_memory      (nb_bypass_memory     ),
+    _size_store_queue      (size_store_queue     ),
+    _size_load_queue       (size_load_queue      ),
+    _size_context_id       (static_cast<uint32_t>(log2(_nb_context         ))),
+    _size_front_end_id     (static_cast<uint32_t>(log2(_nb_front_end       ))),
+    _size_ooo_engine_id    (static_cast<uint32_t>(log2(_nb_ooo_engine      ))),
+    _size_rob_id           (static_cast<uint32_t>(log2(_nb_packet          ))),
+    _size_general_register (static_cast<uint32_t>(log2(_nb_general_register))),
+    _size_special_register (static_cast<uint32_t>(log2(_nb_special_register))),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_rob_id        (_size_rob_id        > 0),
+    _have_port_load_queue_ptr(_size_load_queue    > 1)
+                          uint32_t size_load_queue    ,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
+    _size_queue              = size_queue           ;
+    _nb_inst_retire          = nb_inst_retire       ;
+    _nb_context              = nb_context           ;
+    _nb_front_end            = nb_front_end         ;
+    _nb_ooo_engine           = nb_ooo_engine        ;
+    _nb_packet               = nb_packet            ;
+    _nb_general_register     = nb_general_register  ;
+    _nb_special_register     = nb_special_register  ;
+    _nb_gpr_write            = nb_gpr_write         ;
+    _nb_spr_write            = nb_spr_write         ;
+    _nb_bypass_write         = nb_bypass_write      ;
+    _nb_bypass_memory        = nb_bypass_memory     ;
     test();
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(_nb_context         );
+        _size_front_end_id       = log2(_nb_front_end       );
+        _size_ooo_engine_id      = log2(_nb_ooo_engine      );
+        _size_rob_ptr            = log2(_nb_packet          );
+        _size_general_register   = log2(_nb_general_register);
+        _size_special_register   = log2(_nb_special_register);
+        _size_general_data       = size_general_data         ;
+        _size_special_data       = size_special_data         ;
+        _size_store_queue_ptr    = log2(size_store_queue    );
+        _size_load_queue_ptr     = log2(size_load_queue     );
+        _have_port_context_id    = _size_context_id     > 0;
+        _have_port_front_end_id  = _size_front_end_id   > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id  > 0;
+        _have_port_rob_ptr       = _size_rob_ptr        > 0;
+        _have_port_load_queue_ptr= _size_load_queue_ptr > 0;
+        copy();
+      }
     log_printf(FUNC,Reservation_station,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Reservation_station::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_queue            (param._size_queue            ),
+//     _nb_inst_retire        (param._nb_inst_retire        ),
+//     _nb_context            (param._nb_context            ),
+//     _nb_front_end          (param._nb_front_end          ),
+//     _nb_ooo_engine         (param._nb_ooo_engine         ),
+//     _nb_packet             (param._nb_packet             ),
+//     _size_general_data     (param._size_general_data     ),
+//     _size_special_data     (param._size_special_data     ),
+//     _nb_general_register   (param._nb_general_register   ),
+//     _nb_special_register   (param._nb_special_register   ),
+//     _nb_gpr_write          (param._nb_gpr_write          ),
+//     _nb_spr_write          (param._nb_spr_write          ),
+//     _nb_bypass_write       (param._nb_bypass_write       ),
+//     _nb_bypass_memory      (param._nb_bypass_memory      ),
+//     _size_store_queue      (param._size_store_queue      ),
+//     _size_load_queue       (param._size_load_queue       ),
+//     _size_context_id       (param._size_context_id       ),
+//     _size_front_end_id     (param._size_front_end_id     ),
+//     _size_ooo_engine_id    (param._size_ooo_engine_id    ),
+//     _size_rob_id           (param._size_rob_id           ),
+//     _size_general_register (param._size_general_register ),
+//     _size_special_register (param._size_special_register ),
+//     _have_port_context_id    (param._have_port_context_id   ),
+//     _have_port_front_end_id  (param._have_port_front_end_id ),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+//     _have_port_rob_id        (param._have_port_rob_id       ),
+//     _have_port_load_queue_ptr(param._have_port_load_queue_ptr)
+//   {
+//     log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Reservation_station,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Reservation_station::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _size_queue            (param._size_queue            ),
+    _nb_inst_retire        (param._nb_inst_retire        ),
+    _nb_context            (param._nb_context            ),
+    _nb_front_end          (param._nb_front_end          ),
+    _nb_ooo_engine         (param._nb_ooo_engine         ),
+    _nb_packet             (param._nb_packet             ),
+    _size_general_data     (param._size_general_data     ),
+    _size_special_data     (param._size_special_data     ),
+    _nb_general_register   (param._nb_general_register   ),
+    _nb_special_register   (param._nb_special_register   ),
+    _nb_gpr_write          (param._nb_gpr_write          ),
+    _nb_spr_write          (param._nb_spr_write          ),
+    _nb_bypass_write       (param._nb_bypass_write       ),
+    _nb_bypass_memory      (param._nb_bypass_memory      ),
+    _size_store_queue      (param._size_store_queue      ),
+    _size_load_queue       (param._size_load_queue       ),
+    _size_context_id       (param._size_context_id       ),
+    _size_front_end_id     (param._size_front_end_id     ),
+    _size_ooo_engine_id    (param._size_ooo_engine_id    ),
+    _size_rob_id           (param._size_rob_id           ),
+    _size_general_register (param._size_general_register ),
+    _size_special_register (param._size_special_register ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_rob_id        (param._have_port_rob_id       ),
+    _have_port_load_queue_ptr(param._have_port_load_queue_ptr)
+#define FUNCTION "Reservation_station::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
-    test();
     log_printf(FUNC,Reservation_station,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Reservation_station::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Reservation_station::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Reservation_station,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Parameters_print.cpp

-              r81
+              r88
     xml.singleton_begin("nb_bypass_write    "); xml.attribut("value",toString(_nb_bypass_write    )); xml.singleton_end();
     xml.singleton_begin("nb_bypass_memory   "); xml.attribut("value",toString(_nb_bypass_memory   )); xml.singleton_end();
     xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
     xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
+//  xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
+//  xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
     xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station.cpp

-              r82
+              r88
     log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
+#if DEBUG_Reservation_station == true
+    log_printf(INFO,Reservation_station,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
 #ifdef SYSTEMC
     log_printf(INFO,Reservation_station,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Reservation_station,FUNCTION,"Allocation of statistics");
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Reservation_station,FUNCTION,"Allocation of statistics");
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,Reservation_station,FUNCTION,"Generate the vhdl");
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,Reservation_station,FUNCTION,"Generate the vhdl");
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     log_printf(INFO,Reservation_station,FUNCTION,"Method - transition");
 …
     // List dependency information
 #endif
+      }
 #endif
     log_printf(FUNC,Reservation_station,FUNCTION,"End");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Reservation_station,FUNCTION,"Generate Statistics file");
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Reservation_station,FUNCTION,"Generate Statistics file");
+        delete _stat;
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_allocation.cpp

-              r82
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       Interface * interface = _interfaces->set_interface(""
 …
      in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
     // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       Interface_fifo * interface = _interfaces->set_interface("insert"
 …
       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_id)
        in_INSERT_ROB_ID         = interface->set_signal_in <Tpacket_t         > ("rob_id"         ,_param->_size_rob_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" ,log2(_param->_size_store_queue));
+       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"  ,log2(_param->_size_load_queue) );
+       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     );
 …
+     }
     // ~~~~~[ Interface : "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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_ooo_engine_id)
     out_RETIRE_OOO_ENGINE_ID  = new SC_OUT(Tcontext_t        ) * [_param->_nb_inst_retire];
     if (_param->_have_port_rob_id)
+    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];
 …
         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_id)
         out_RETIRE_ROB_ID       [i] = interface->set_signal_out<Tpacket_t         > ("rob_id"       ,_param->_size_rob_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" ,log2(_param->_size_store_queue));
+        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"  ,log2(_param->_size_load_queue) );
+        out_RETIRE_LOAD_QUEUE_PTR_WRITE  [i] = interface->set_signal_out<Tlsq_ptr_t> ("load_queue_ptr_write"  ,_param->_size_load_queue_ptr );
         out_RETIRE_HAS_IMMEDIAT [i] = interface->set_signal_out<Tcontrol_t        > ("has_immediat" ,1);
 …
+      }
     // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_GPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_gpr_write];
      if (_param->_have_port_ooo_engine_id)
 …
+      }
     // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_SPR_WRITE_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_spr_write];
      if (_param->_have_port_ooo_engine_id)
 …
+      }
     // ~~~~~[ Interface : "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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];
 …
+      }
     // ~~~~~[ Interface : "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_BYPASS_MEMORY_VAL          = new SC_IN (Tcontrol_t        ) * [_param->_nb_bypass_memory];
      if (_param->_have_port_ooo_engine_id)
 …
+    // ~~~~~[ internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    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];
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#ifdef POSITION
+    _component->generate_file();
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#ifdef POSITION
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
 #ifdef  SYSTEMC_VHDL_COMPATIBILITY

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     delete     in_CLOCK ;
     delete     in_NRESET;
 …
     if (_param->_have_port_ooo_engine_id)
     delete     in_INSERT_OOO_ENGINE_ID ;
     if (_param->_have_port_rob_id)
+    if (_param->_have_port_rob_ptr)
     delete     in_INSERT_ROB_ID        ;
     delete     in_INSERT_OPERATION     ;
 …
     if (_param->_have_port_ooo_engine_id)
     delete [] out_RETIRE_OOO_ENGINE_ID ;
     if (_param->_have_port_rob_id)
+    if (_param->_have_port_rob_ptr)
     delete [] out_RETIRE_ROB_ID        ;
     delete [] out_RETIRE_OPERATION     ;
 …
     // ~~~~~[ internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete []  internal_RETIRE_VAL;
+    delete []  internal_RETIRE_SLOT;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
 }; // end namespace multi_execute_loop
 }; // end namespace core
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //     sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif
     log_printf(FUNC,Reservation_station,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_genMoore.cpp

-              r81
+              r88
   void Reservation_station::genMoore (void)
+  {
+    log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
+    log_begin(Reservation_station,FUNCTION);
+    log_function(Reservation_station,FUNCTION,_name.c_str());
     // ~~~~~[ Interface "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~
 …
             if (_param->_have_port_ooo_engine_id)
             PORT_WRITE(out_RETIRE_OOO_ENGINE_ID [i],_queue[index_find]._ooo_engine_id);
             if (_param->_have_port_rob_id)
+            if (_param->_have_port_rob_ptr)
             PORT_WRITE(out_RETIRE_ROB_ID        [i],_queue[index_find]._rob_id);
             PORT_WRITE(out_RETIRE_OPERATION     [i],_queue[index_find]._operation);
 …
+      }
     log_printf(FUNC,Reservation_station,FUNCTION,"End");
+    log_end(Reservation_station,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/src/Reservation_station_transition.cpp

-              r81
+              r88
 #ifdef  SYSTEMC_VHDL_COMPATIBILITY
+#define dump_queue() \
+  do\
+  {\
+   log_printf(TRACE,Reservation_station,FUNCTION," * dump queue");\
+   log_printf(TRACE,Reservation_station,FUNCTION,"   * nb_elt : %d",_queue_nb_elt);\
+   for (uint32_t j=0;j<_param->_size_queue; j++)\
+   {\
+     cout << "\t"\
+          << "[" << j << "] "\
+          << "{" << _queue[j]._rob_id << " - "<< _queue[j]._context_id << "} " << " - "<< _queue[j]._front_end_id << "} " << " - "<< _queue[j]._ooo_engine_id << "} "\
+          << _queue[j]._data_ra_val << ", "\
+          << _queue[j]._num_reg_ra  << " - "\
+          << _queue[j]._data_rb_val << ","\
+          << _queue[j]._num_reg_rb  << " - "\
+          << _queue[j]._data_rc_val << ","\
+          << _queue[j]._num_reg_rc  \
+          << endl;\
+    }\
+  } while (0)
+#else
+#define dump_queue() \
+  do\
+  {\
+   log_printf(TRACE,Reservation_station,FUNCTION," * dump queue");\
+   log_printf(TRACE,Reservation_station,FUNCTION,"   * nb_elt : %d",_queue_nb_elt);\
+   for (uint32_t j=0;j<_param->_size_queue; j++)\
+   {\
+     cout << "\t"\
+          << "[" << (*_queue_control)[j] << "] "\
+          << "{" << _queue[(*_queue_control)[j]]._rob_id << " - "<< _queue[(*_queue_control)[j]]._context_id << "} " << " - "<< _queue[(*_queue_control)[j]]._front_end_id << "} " << " - "<< _queue[(*_queue_control)[j]]._ooo_engine_id << "} "\
+          << _queue[(*_queue_control)[j]]._data_ra_val << ", "\
+          << _queue[(*_queue_control)[j]]._num_reg_ra  << " - "\
+          << _queue[(*_queue_control)[j]]._data_rb_val << ","\
+          << _queue[(*_queue_control)[j]]._num_reg_rb  << " - "\
+          << _queue[(*_queue_control)[j]]._data_rc_val << ","\
+          << _queue[(*_queue_control)[j]]._num_reg_rc  \
+          << endl;\
+    }\
+  } while (0)
+#define dump_queue()                                                    \
+  do                                                                    \
+    {                                                                   \
+      log_printf(TRACE,Reservation_station,FUNCTION,"  * Dump Reservation Station");  \
+      for (uint32_t it_dump=0;it_dump<_param->_size_queue; it_dump++)   \
+        log_printf(TRACE,Reservation_station,FUNCTION,"    * [%.4d] %.2d %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.2x, %.1d %.4d, %.1d %.4d (%s)", \
+                   it_dump,                                             \
+                   _queue[it_dump]._context_id           ,              \
+                   _queue[it_dump]._front_end_id         ,              \
+                   _queue[it_dump]._ooo_engine_id        ,              \
+                   _queue[it_dump]._rob_id               ,              \
+                   _queue[it_dump]._type                 ,              \
+                   _queue[it_dump]._operation            ,              \
+                   _queue[it_dump]._store_queue_ptr_write,              \
+                   _queue[it_dump]._load_queue_ptr_write ,              \
+                   _queue[it_dump]._has_immediat         ,              \
+                   _queue[it_dump]._immediat             ,              \
+                   _queue[it_dump]._num_reg_ra           ,              \
+                   _queue[it_dump]._data_ra_val          ,              \
+                   _queue[it_dump]._data_ra              ,              \
+                   _queue[it_dump]._num_reg_rb           ,              \
+                   _queue[it_dump]._data_rb_val          ,              \
+                   _queue[it_dump]._data_rb              ,              \
+                   _queue[it_dump]._num_reg_rc           ,              \
+                   _queue[it_dump]._data_rc_val          ,              \
+                   _queue[it_dump]._data_rc              ,              \
+                   _queue[it_dump]._write_rd             ,              \
+                   _queue[it_dump]._num_reg_rd           ,              \
+                   _queue[it_dump]._write_re             ,              \
+                   _queue[it_dump]._num_reg_re           ,              \
+                   toString_type(_queue[it_dump]._type).c_str());       \
+    } while (0)
+#else
+#define dump_queue()                                                    \
+  do                                                                    \
+    {                                                                   \
+      log_printf(TRACE,Reservation_station,FUNCTION,"  * Dump Reservation Station"); \
+      log_printf(TRACE,Reservation_station,FUNCTION,"    * nb_elt : %d",_queue_control->nb_elt()); \
+      for (uint32_t it_dump=0;it_dump<_param->_size_queue; it_dump++)   \
+        log_printf(TRACE,Reservation_station,FUNCTION,"    * [%.4d] %.2d %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.8x, %.4d %.1d %.2x, %.1d %.4d, %.1d %.4d (%s)", \
+                   (*_queue_control)[it_dump],                          \
+                   _queue[(*_queue_control)[it_dump]]._context_id           , \
+                   _queue[(*_queue_control)[it_dump]]._front_end_id         , \
+                   _queue[(*_queue_control)[it_dump]]._ooo_engine_id        , \
+                   _queue[(*_queue_control)[it_dump]]._rob_id               , \
+                   _queue[(*_queue_control)[it_dump]]._type                 , \
+                   _queue[(*_queue_control)[it_dump]]._operation            , \
+                   _queue[(*_queue_control)[it_dump]]._store_queue_ptr_write, \
+                   _queue[(*_queue_control)[it_dump]]._load_queue_ptr_write , \
+                   _queue[(*_queue_control)[it_dump]]._has_immediat         , \
+                   _queue[(*_queue_control)[it_dump]]._immediat             , \
+                   _queue[(*_queue_control)[it_dump]]._num_reg_ra           , \
+                   _queue[(*_queue_control)[it_dump]]._data_ra_val          , \
+                   _queue[(*_queue_control)[it_dump]]._data_ra              , \
+                   _queue[(*_queue_control)[it_dump]]._num_reg_rb           , \
+                   _queue[(*_queue_control)[it_dump]]._data_rb_val          , \
+                   _queue[(*_queue_control)[it_dump]]._data_rb              , \
+                   _queue[(*_queue_control)[it_dump]]._num_reg_rc           , \
+                   _queue[(*_queue_control)[it_dump]]._data_rc_val          , \
+                   _queue[(*_queue_control)[it_dump]]._data_rc              , \
+                   _queue[(*_queue_control)[it_dump]]._write_rd             , \
+                   _queue[(*_queue_control)[it_dump]]._num_reg_rd           , \
+                   _queue[(*_queue_control)[it_dump]]._write_re             , \
+                   _queue[(*_queue_control)[it_dump]]._num_reg_re           , \
+                   toString_type(_queue[(*_queue_control)[it_dump]]._type).c_str());       \
+    } while (0)
 #endif
 …
   void Reservation_station::transition (void)
+  {
+    log_printf(FUNC,Reservation_station,FUNCTION,"Begin");
+    log_begin(Reservation_station,FUNCTION);
+    log_function(Reservation_station,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
                 //uint32_t index = (*_queue_control)[i];
                 log_printf(NONE,Reservation_station,FUNCTION,"POP  [%d]",i);
+                log_printf(NONE,Reservation_station,FUNCTION,"  * POP  [%d]",i);
                 uint32_t index  = internal_RETIRE_SLOT[i];
 …
 //                   << " * index       : " << index << endl;
                 log_printf(NONE,Reservation_station,FUNCTION," * index         : %d",index);
+                log_printf(NONE,Reservation_station,FUNCTION,"    * index         : %d",index);
+              }
+          }
 …
                     if (PORT_READ(in_GPR_WRITE_NUM_REG [j]) == _queue[index]._num_reg_ra)
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> GPR_WRITE     [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> GPR_WRITE     [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
                         _queue[index]._data_ra_val = 1;
                         _queue[index]._data_ra     = PORT_READ(in_GPR_WRITE_DATA [j]);
 …
                     if (PORT_READ(in_GPR_WRITE_NUM_REG [j]) == _queue[index]._num_reg_rb)
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> GPR_WRITE     [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> GPR_WRITE     [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
                         _queue[index]._data_rb_val = 1;
                         _queue[index]._data_rb     = PORT_READ(in_GPR_WRITE_DATA [j]);
 …
                     (PORT_READ(in_SPR_WRITE_NUM_REG       [j]) == _queue[index]._num_reg_rc))
+                  {
                     log_printf(TRACE,Reservation_station,FUNCTION," -> SPR_WRITE     [%d] - Hit queue[%d]-SPR_RC[%d]",i,index,_queue[index]._num_reg_rc);
+                    log_printf(TRACE,Reservation_station,FUNCTION,"    -> SPR_WRITE     [%d] - Hit queue[%d]-SPR_RC[%d]",i,index,_queue[index]._num_reg_rc);
                     _queue[index]._data_rc_val = 1;
                     _queue[index]._data_rc     = PORT_READ(in_SPR_WRITE_DATA [j]);
 …
                     if (PORT_READ(in_BYPASS_WRITE_GPR_NUM_REG[j]) == _queue[index]._num_reg_ra)
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_WRITE  [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> BYPASS_WRITE  [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
                         _queue[index]._data_ra_val = 1;
                         _queue[index]._data_ra     = PORT_READ(in_BYPASS_WRITE_GPR_DATA [j]);
 …
                     if (PORT_READ(in_BYPASS_WRITE_GPR_NUM_REG [j]) == _queue[index]._num_reg_rb)
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_WRITE  [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> BYPASS_WRITE  [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
                         _queue[index]._data_rb_val = 1;
                         _queue[index]._data_rb     = PORT_READ(in_BYPASS_WRITE_GPR_DATA [j]);
 …
                         (PORT_READ(in_BYPASS_WRITE_SPR_NUM_REG[j]) == _queue[index]._num_reg_rc))
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_WRITE  [%d] - Hit queue[%d]-SPR_RC[%d]",i,index,_queue[index]._num_reg_rc);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> BYPASS_WRITE  [%d] - Hit queue[%d]-SPR_RC[%d]",i,index,_queue[index]._num_reg_rc);
                         _queue[index]._data_rc_val = 1;
                         _queue[index]._data_rc     = PORT_READ(in_BYPASS_WRITE_SPR_DATA [j]);
 …
                     if (PORT_READ(in_BYPASS_MEMORY_NUM_REG [j]) == _queue[index]._num_reg_ra)
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_MEMORY [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> BYPASS_MEMORY [%d] - Hit queue[%d]-GPR_RA[%d]",i,index,_queue[index]._num_reg_ra);
                         _queue[index]._data_ra_val = 1;
                         _queue[index]._data_ra     = PORT_READ(in_BYPASS_MEMORY_DATA [j]);
 …
                     if (PORT_READ(in_BYPASS_MEMORY_NUM_REG [j]) == _queue[index]._num_reg_rb)
+                      {
                         log_printf(TRACE,Reservation_station,FUNCTION," -> BYPASS_MEMORY [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
+                        log_printf(TRACE,Reservation_station,FUNCTION,"    -> BYPASS_MEMORY [%d] - Hit queue[%d]-GPR_RB[%d]",i,index,_queue[index]._num_reg_rb);
                         _queue[index]._data_rb_val = 1;
                         _queue[index]._data_rb     = PORT_READ(in_BYPASS_MEMORY_DATA [j]);
 …
             (    internal_INSERT_ACK  == 1))
+          {
             log_printf(TRACE,Reservation_station,FUNCTION,"PUSH");
+            log_printf(TRACE,Reservation_station,FUNCTION,"  * PUSH");
             // Write in reservation station
 …
             index = _queue_control->push();
 #endif
             log_printf(TRACE,Reservation_station,FUNCTION," * index         : %d",index);
+            log_printf(TRACE,Reservation_station,FUNCTION,"    * index         : %d",index);
             if (_param->_have_port_context_id)
 …
             if (_param->_have_port_ooo_engine_id)
             _queue[index]._ooo_engine_id   = PORT_READ(in_INSERT_OOO_ENGINE_ID  );
             if (_param->_have_port_rob_id)
+            if (_param->_have_port_rob_ptr)
             _queue[index]._rob_id          = PORT_READ(in_INSERT_ROB_ID         );
             _queue[index]._operation       = PORT_READ(in_INSERT_OPERATION      );
 …
+      }
+    dump_queue();
     end_cycle ();
     log_printf(FUNC,Reservation_station,FUNCTION,"End");
+    log_end(Reservation_station,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Read_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/configuration.cfg

-              r81
+              r88
 Read_unit
        4       *2      # size_read_queue
        4       *2      # size_reservation_station
+       8       *2      # size_read_queue
+       8       *2      # size_reservation_station
        1       *2      # nb_context
        1       *2      # nb_front_end
        4       *2      # nb_ooo_engine
+       4       *4      # nb_ooo_engine
       64      *2      # nb_packet
       32      *2      # size_general_data
 …
       64      *2      # nb_general_register
       16      *2      # nb_special_register
        2       *2      # nb_gpr_write
        2       *2      # nb_spr_write
        4       *2      # size_store_queue
        4       *4      # size_load_queue
        2       *2      # nb_inst_retire
        2       *2      # nb_bypass_write
        2       *2      # nb_bypass_memory
+       4       *4      # nb_gpr_write
+       4       *4      # nb_spr_write
+       4       *2      # size_store_queue
+       4       *4      # size_load_queue
+       4       *4      # nb_inst_retire
+       4       *4      # nb_bypass_write
+       4       *4      # nb_bypass_memory

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_inst_retire          ,
          _nb_bypass_write         ,
+         _nb_bypass_memory        );
+         _nb_bypass_memory        ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/src/test.cpp

-              r82
+              r88
  */
 #define NB_ITERATION  1
 #define CYCLE_MAX     (128*NB_ITERATION)
+#define NB_ITERATION  16
+#define CYCLE_MAX     (1024*NB_ITERATION)
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/SelfTest/include/test.h"
 #include "Common/include/Test.h"
+#include "Common/include/BitManipulation.h"
 #include "Behavioural/include/Allocation.h"
+class write_req_t
+{
+  public : uint32_t ooo;
+  public : uint32_t reg;
+  write_req_t (uint32_t ooo,
+               uint32_t reg)
+  {
+    this->ooo = ooo;
+    this->reg = reg;
+  }
+};
 void test (string name,
 …
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Read_unit * _Read_unit = new Read_unit
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Read_unit, in_READ_UNIT_IN_OOO_ENGINE_ID         );
   if (_param->_have_port_packet_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             );
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_inst_retire);
   if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr)
   INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Read_unit,out_READ_UNIT_OUT_OPERATION            ,_param->_nb_inst_retire);
 …
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
+  // Initialisation
+  const uint32_t seed = 0;
+//const uint32_t seed = static_cast<uint32_t>(time(NULL));
+  srand(seed);
+  SC_START(0);
   Time * _time = new Time();
 …
    * Simulation - Begin
    ********************************************************/
+  {
   // Initialisation
+  const uint32_t seed = 0;
+//const uint32_t seed = static_cast<uint32_t>(time(NULL));
+  srand(seed);
+  SC_START(0);
+  const uint32_t nb_request = _param->_nb_packet;
+  Tcontext_t         _ooo_engine_id [nb_request];
+  Tcontrol_t         _read_ra    [nb_request];
+  Tgeneral_address_t _num_reg_ra [nb_request];
+  Tcontrol_t         _read_rb    [nb_request];
+  Tgeneral_address_t _num_reg_rb [nb_request];
+  Tcontrol_t         _read_rc    [nb_request];
+  Tspecial_address_t _num_reg_rc [nb_request];
+  // emulation of registerFile
+  Tcontrol_t         _gpr_val    [_param->_nb_general_register][_param->_nb_ooo_engine];
+  Tgeneral_data_t    _gpr        [_param->_nb_general_register][_param->_nb_ooo_engine];
+  Tcontrol_t         _spr_val    [_param->_nb_special_register][_param->_nb_ooo_engine];
+  Tspecial_data_t    _spr        [_param->_nb_special_register][_param->_nb_ooo_engine];
   LABEL("Initialisation");
+  LABEL("Reset");
+  in_READ_UNIT_IN_VAL ->write(0);
+  for (uint32_t i=0; i<_param->_nb_inst_retire  ; i++)
+    in_READ_UNIT_OUT_ACK [i]->write(0);
+  for (uint32_t i=0; i<_param->_nb_gpr_write    ; i++)
+    in_GPR_WRITE_VAL               [i]->write(0);
+  for (uint32_t i=0; i<_param->_nb_spr_write    ; i++)
+    in_SPR_WRITE_VAL               [i]->write(0);
+  for (uint32_t i=0; i<_param->_nb_bypass_write ; i++)
+    {
+      in_BYPASS_WRITE_GPR_VAL      [i]->write(0);
+      in_BYPASS_WRITE_SPR_VAL      [i]->write(0);
+    }
+  for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
+    in_BYPASS_MEMORY_VAL           [i]->write(0);
   in_NRESET->write(0);
   SC_START(5);
   in_NRESET->write(1);
+  in_NRESET->write(1);
   LABEL("Loop of Test");
 …
       LABEL("Iteration %d",iteration);
+      SC_START(1);
+      int32_t percent_transaction_queue_in     = (rand()%50)+25;
+      int32_t percent_transaction_queue_out    = (rand()%50)+25;
+      int32_t percent_registerfile_valid       = (rand()%50)+25;
+      int32_t percent_transaction_registerfile = (rand()%50)+25;
+      int32_t percent_transaction_bypass       = (rand()%50)+25;
+      LABEL("Initialisation");
+      for (uint32_t i=0; i<nb_request; i++)
+        {
+          _ooo_engine_id   [i] = rand()% _param->_nb_ooo_engine            ;
+          _read_ra         [i] = rand()% 2                              ;
+          _num_reg_ra      [i] = rand()% _param->_nb_general_register   ;
+          _read_rb         [i] = rand()% 2                              ;
+          _num_reg_rb      [i] = rand()% _param->_nb_general_register   ;
+          _read_rc         [i] = rand()% 2                              ;
+          _num_reg_rc      [i] = rand()% _param->_nb_special_register   ;
+        }
+      // emulation of registerFile
+      for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
+        {
+          for (uint32_t i=0; i<_param->_nb_general_register; i++)
+            {
+              _gpr_val      [i][j] = ((rand()%100) < percent_registerfile_valid);
+              _gpr          [i][j] = range<Tgeneral_data_t>(rand(),_param->_size_general_data);
+            }
+          for (uint32_t i=0; i<_param->_nb_special_register; i++)
+            {
+              _spr_val      [i][j] = ((rand()%100) < percent_registerfile_valid);
+              _spr          [i][j] = range<Tspecial_data_t>(rand(),_param->_size_special_data);
+            }
+        }
+      // End initialisation .......
+      uint32_t request_in  = 0;
+      uint32_t request_out = 0;
+      bool     request_out_wait [nb_request];
+      for (uint32_t i=0; i<nb_request; i++)
+        request_out_wait [i] = true;
+//       bool can_gpr_use [_param->_nb_ooo_engine][_param->_nb_general_register];
+//       bool can_spr_use [_param->_nb_ooo_engine][_param->_nb_special_register];
+      list<write_req_t> write_req_gpr;
+      list<write_req_t> write_req_spr;
+      while (request_out < nb_request)
+        {
+          LABEL("request_in         : %d",request_in );
+          LABEL("request_out        : %d",request_out);
+          for (uint32_t i=0; i<nb_request; i++)
+            if (request_out_wait [i])
+              LABEL("request_out_wait   : %d",i);
+          LABEL("write_req_gpr size : %d",write_req_gpr.size());
+          LABEL("write_req_spr size : %d",write_req_spr.size());
+//        for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
+//          {
+//            for (uint32_t i=0; i<_param->_nb_general_register; i++)
+//              can_gpr_use [j][i] = true;
+//            for (uint32_t i=0; i<_param->_nb_special_register; i++)
+//              can_spr_use [j][i] = true;
+//          }
+          Tcontrol_t         read_unit_in_val = (request_in < nb_request) and ((rand()%100) < percent_transaction_queue_in);
+          Tcontext_t         read_unit_in_ooo_engine_id;
+          Tgeneral_address_t read_unit_in_num_reg_ra;
+          Tgeneral_address_t read_unit_in_num_reg_rb;
+          Tspecial_address_t read_unit_in_num_reg_rc;
+          in_READ_UNIT_IN_VAL         ->write(read_unit_in_val);
+          if (read_unit_in_val)
+            {
+              bool               data_val;
+              read_unit_in_ooo_engine_id = _ooo_engine_id [request_in];
+              read_unit_in_num_reg_ra    = _num_reg_ra [request_in];
+              read_unit_in_num_reg_rb    = _num_reg_rb [request_in];
+              read_unit_in_num_reg_rc    = _num_reg_rc [request_in];
+              if (_param->_have_port_context_id)
+              in_READ_UNIT_IN_CONTEXT_ID     ->write((2*read_unit_in_ooo_engine_id)%_param->_nb_context  );
+              if (_param->_have_port_front_end_id)
+              in_READ_UNIT_IN_FRONT_END_ID   ->write((3*read_unit_in_ooo_engine_id)%_param->_nb_front_end);
+              if (_param->_have_port_ooo_engine_id)
+              in_READ_UNIT_IN_OOO_ENGINE_ID  ->write(read_unit_in_ooo_engine_id);
+              if (_param->_have_port_rob_ptr)
+              in_READ_UNIT_IN_PACKET_ID   ->write(request_in);
+              in_READ_UNIT_IN_OPERATION   ->write(0);
+              in_READ_UNIT_IN_TYPE        ->write(0);
+              in_READ_UNIT_IN_STORE_QUEUE_PTR_WRITE->write(0);
+              if (_param->_have_port_load_queue_ptr)
+              in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ->write(0);
+              in_READ_UNIT_IN_HAS_IMMEDIAT->write(0);
+              in_READ_UNIT_IN_IMMEDIAT    ->write(0);
+              in_READ_UNIT_IN_READ_RA     ->write(_read_ra[request_in]);
+              data_val = not(_read_ra[request_in]) or _gpr_val[read_unit_in_num_reg_ra][read_unit_in_ooo_engine_id];
+              if (not data_val)
+                if (rand ()%2)
+                  write_req_gpr.push_back (write_req_t(read_unit_in_ooo_engine_id,read_unit_in_num_reg_ra));
+                else
+                  write_req_gpr.push_front(write_req_t(read_unit_in_ooo_engine_id,read_unit_in_num_reg_ra));
+              in_READ_UNIT_IN_NUM_REG_RA  ->write(read_unit_in_num_reg_ra);
+//            in_READ_UNIT_IN_DATA_RA_VAL ->write(data_val);
+//            in_READ_UNIT_IN_DATA_RA     ->write((data_val)?_gpr[read_unit_in_num_reg_ra][read_unit_in_ooo_engine_id]:0);
+              in_READ_UNIT_IN_READ_RB     ->write(_read_rb[request_in]);
+              data_val = not(_read_rb[request_in]) or _gpr_val[read_unit_in_num_reg_rb][read_unit_in_ooo_engine_id];
+              if (not data_val)
+                if (rand ()%2)
+                  write_req_gpr.push_back (write_req_t(read_unit_in_ooo_engine_id,read_unit_in_num_reg_rb));
+                else
+                  write_req_gpr.push_front(write_req_t(read_unit_in_ooo_engine_id,read_unit_in_num_reg_rb));
+              in_READ_UNIT_IN_NUM_REG_RB  ->write(read_unit_in_num_reg_rb);
+//            in_READ_UNIT_IN_DATA_RB_VAL ->write(data_val);
+//            in_READ_UNIT_IN_DATA_RB     ->write((data_val)?_gpr[read_unit_in_num_reg_rb][read_unit_in_ooo_engine_id]:0);
+              in_READ_UNIT_IN_READ_RC     ->write(_read_rc[request_in]);
+              data_val = not(_read_rc[request_in]) or _spr_val[read_unit_in_num_reg_rc][read_unit_in_ooo_engine_id];
+              if (not data_val)
+                if (rand ()%2)
+                  write_req_spr.push_back (write_req_t(read_unit_in_ooo_engine_id,read_unit_in_num_reg_rc));
+                else
+                  write_req_spr.push_front(write_req_t(read_unit_in_ooo_engine_id,read_unit_in_num_reg_rc));
+              in_READ_UNIT_IN_NUM_REG_RC  ->write(read_unit_in_num_reg_rc);
+//            in_READ_UNIT_IN_DATA_RC_VAL ->write(data_val);
+//            in_READ_UNIT_IN_DATA_RC     ->write((data_val)?_spr[read_unit_in_num_reg_rc][read_unit_in_ooo_engine_id]:0);
+              in_READ_UNIT_IN_WRITE_RD    ->write(0);
+              in_READ_UNIT_IN_NUM_REG_RD  ->write(0);
+              in_READ_UNIT_IN_WRITE_RE    ->write(0);
+              in_READ_UNIT_IN_NUM_REG_RE  ->write(0);
+//            can_gpr_use [read_unit_in_ooo_engine_id][read_unit_in_num_reg_ra] = false;
+//            can_gpr_use [read_unit_in_ooo_engine_id][read_unit_in_num_reg_rb] = false;
+//            can_spr_use [read_unit_in_ooo_engine_id][read_unit_in_num_reg_rc] = false;
+            }
+          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+            in_READ_UNIT_OUT_ACK[i]->write((rand()%100)<percent_transaction_queue_out);
+          // RegisterFile access
+          for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
+            {
+              Tcontrol_t ack = (rand()%100) < percent_transaction_registerfile;
+              in_GPR_READ_ACK      [i]->write(ack);
+              SC_START(0);
+              if (out_GPR_READ_VAL [i]->read())
+                {
+                  Tgeneral_address_t num_reg    = out_GPR_READ_NUM_REG       [i]->read();
+                  Tcontext_t         ooo_engine = (_param->_have_port_ooo_engine_id)?out_GPR_READ_OOO_ENGINE_ID [i]->read():0;
+                  Tgeneral_data_t    data       = _gpr    [num_reg][ooo_engine];
+                  Tcontrol_t         data_val   = _gpr_val[num_reg][ooo_engine];
+                  if (ack)
+                    LABEL(" * GPR_READ      [%d] - gpr[%d][%d] ->  (%d) 0x%x",i,num_reg,ooo_engine,data_val,data);
+                  in_GPR_READ_DATA     [i]->write(data);
+                  in_GPR_READ_DATA_VAL [i]->write(data_val);
+                }
+            }
+          for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
+            {
+              Tcontrol_t ack = (rand()%100) < percent_transaction_registerfile;
+              in_SPR_READ_ACK      [i]->write(ack);
+              SC_START(0);
+              if (out_SPR_READ_VAL [i]->read())
+                {
+                  Tspecial_address_t num_reg    = out_SPR_READ_NUM_REG       [i]->read();
+                  Tcontext_t         ooo_engine = (_param->_have_port_ooo_engine_id)?out_SPR_READ_OOO_ENGINE_ID [i]->read():0;
+                  Tspecial_data_t    data       = _spr    [num_reg][ooo_engine];
+                  Tcontrol_t         data_val   = _spr_val[num_reg][ooo_engine];
+                  if (ack)
+                    LABEL(" * SPR_READ      [%d] - spr[%d][%d] ->  (%d) 0x%x",i,num_reg,ooo_engine,data_val,data);
+                  in_SPR_READ_DATA     [i]->write(data);
+                  in_SPR_READ_DATA_VAL [i]->write(data_val);
+                }
+            }
+          list<write_req_t>::iterator it_gpr = write_req_gpr.begin();
+          list<write_req_t>::iterator it_spr = write_req_spr.begin();
+          LABEL("Bypass Network :");
+          for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
+            {
+              Tcontext_t         ooo_engine = (it_gpr != write_req_gpr.end())?(*it_gpr).ooo:0;
+              Tgeneral_address_t num_reg    = (it_gpr != write_req_gpr.end())?(*it_gpr).reg:0;
+              Tcontrol_t         val     = (_gpr_val [num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_registerfile):0;
+              Tgeneral_data_t    data    = range<Tgeneral_data_t>(rand(),_param->_size_general_data);
+              val = (val// and can_spr_use [ooo_engine][num_reg]
+                     and (it_gpr != write_req_gpr.end()));
+              in_GPR_WRITE_VAL            [i]->write(val);
+              if (_param->_have_port_ooo_engine_id)
+              in_GPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
+              in_GPR_WRITE_NUM_REG        [i]->write(num_reg);
+              in_GPR_WRITE_DATA           [i]->write(data);
+              if (val)
+                {
+                  LABEL(" * GPR_WRITE     [%d] - gpr[%d][%d] <- 0x%x",i,num_reg,ooo_engine,data);
+//                can_gpr_use [ooo_engine][num_reg] = false;
+                  _gpr     [num_reg][ooo_engine] = data;
+                  _gpr_val [num_reg][ooo_engine] = 1;
+                }
+              if (it_gpr != write_req_gpr.end())
+                it_gpr ++;
+            }
+          for (uint32_t i=0; i<_param->_nb_spr_write; i++)
+            {
+              Tcontext_t         ooo_engine = (it_spr != write_req_spr.end())?(*it_spr).ooo:0;
+              Tgeneral_address_t num_reg    = (it_spr != write_req_spr.end())?(*it_spr).reg:0;
+              Tcontrol_t         val     = (_spr_val [num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_registerfile):0;
+              Tspecial_data_t    data    = range<Tspecial_data_t>(rand(),_param->_size_special_data);
+              val = (val // and can_spr_use [ooo_engine][num_reg]
+                     and (it_spr != write_req_spr.end()));
+              in_SPR_WRITE_VAL            [i]->write(val);
+              if (_param->_have_port_ooo_engine_id)
+              in_SPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
+              in_SPR_WRITE_NUM_REG        [i]->write(num_reg);
+              in_SPR_WRITE_DATA           [i]->write(data);
+              if (val == 1)
+                {
+                  LABEL(" * SPR_WRITE     [%d] - spr[%d][%d] <- 0x%x",i,num_reg,ooo_engine,data);
+//                can_spr_use [ooo_engine][num_reg] = false;
+                  _spr     [num_reg][ooo_engine] = data;
+                  _spr_val [num_reg][ooo_engine] = 1;
+                }
+              if (it_spr != write_req_spr.end())
+                it_spr ++;
+            }
+          for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
+            {
+              Tcontext_t         ooo_engine = (it_gpr != write_req_gpr.end())?(*it_gpr).ooo:0;
+              Tgeneral_address_t gpr_num_reg= (it_gpr != write_req_gpr.end())?(*it_gpr).reg:0;
+              if (_param->_have_port_ooo_engine_id)
+              in_BYPASS_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
+              Tcontrol_t         gpr_val     = (_gpr_val [gpr_num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_bypass):0;
+              Tgeneral_data_t    gpr_data    = range<Tgeneral_data_t>(rand(),_param->_size_general_data);
+              gpr_val = (gpr_val // and can_gpr_use [ooo_engine][gpr_num_reg]
+                         and (it_gpr != write_req_gpr.end()));
+              in_BYPASS_WRITE_GPR_VAL    [i]->write(gpr_val);
+              in_BYPASS_WRITE_GPR_NUM_REG[i]->write(gpr_num_reg);
+              in_BYPASS_WRITE_GPR_DATA   [i]->write(gpr_data);
+              if (gpr_val)
+                {
+                  LABEL(" * BYPASS_WRITE  [%d] - gpr[%d][%d] <- 0x%x",i,gpr_num_reg,ooo_engine,gpr_data);
+//                can_gpr_use [ooo_engine][gpr_num_reg] = false;
+                  _gpr     [gpr_num_reg][ooo_engine] = gpr_data;
+                  _gpr_val [gpr_num_reg][ooo_engine] = 1;
+                }
+              if (it_gpr != write_req_gpr.end())
+                it_gpr ++;
+              Tspecial_address_t spr_num_reg = (it_spr != write_req_spr.end())?(*it_spr).reg:0;
+              Tcontrol_t         spr_val     = (_spr_val [spr_num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_bypass):0;
+              Tspecial_data_t    spr_data    = range<Tspecial_data_t>(rand(),_param->_size_special_data);
+              spr_val = (spr_val // and can_spr_use [ooo_engine][spr_num_reg]
+                         and (it_spr != write_req_spr.end()) and ((*it_spr).ooo == ooo_engine));
+              in_BYPASS_WRITE_SPR_VAL    [i]->write(spr_val);
+              in_BYPASS_WRITE_SPR_NUM_REG[i]->write(spr_num_reg);
+              in_BYPASS_WRITE_SPR_DATA   [i]->write(spr_data);
+              if (spr_val)
+                {
+                  LABEL(" * BYPASS_WRITE  [%d] - spr[%d][%d] <- 0x%x",i,spr_num_reg,ooo_engine,spr_data);
+//                can_spr_use [ooo_engine][spr_num_reg] = false;
+                  _spr     [spr_num_reg][ooo_engine] = spr_data;
+                  _spr_val [spr_num_reg][ooo_engine] = 1;
+                }
+              if (it_spr != write_req_spr.end())
+                it_spr ++;
+            }
+          for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
+            {
+              Tcontext_t         ooo_engine = (it_gpr != write_req_gpr.end())?(*it_gpr).ooo:0;
+              Tgeneral_address_t num_reg    = (it_gpr != write_req_gpr.end())?(*it_gpr).reg:0;
+              if (_param->_have_port_ooo_engine_id)
+              in_BYPASS_MEMORY_OOO_ENGINE_ID [i]->write(ooo_engine);
+              Tcontrol_t         val     = (_gpr_val [num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_bypass):0;
+              Tgeneral_data_t    data    = range<Tgeneral_data_t>(rand(),_param->_size_general_data);
+              val = (val // and can_gpr_use [ooo_engine][num_reg]
+                     and (it_gpr != write_req_gpr.end()));
+              in_BYPASS_MEMORY_VAL    [i]->write(val);
+              in_BYPASS_MEMORY_NUM_REG[i]->write(num_reg);
+              in_BYPASS_MEMORY_DATA   [i]->write(data);
+              if (val)
+                {
+                  LABEL(" * BYPASS_MEMORY [%d] - gpr[%d][%d] <- 0x%x",i,num_reg,ooo_engine,data);
+//                can_gpr_use [ooo_engine][num_reg] = false;
+                  _gpr     [num_reg][ooo_engine] = data;
+                  _gpr_val [num_reg][ooo_engine] = 1;
+                }
+              if (it_gpr != write_req_gpr.end())
+                it_gpr ++;
+            }
+          SC_START(0); // to mealy function
+//        LABEL("Test     READ_UNIT_IN  : "+toString(in_READ_UNIT_IN_VAL->read())+","+toString(out_READ_UNIT_IN_ACK->read()));
+          if (( in_READ_UNIT_IN_VAL->read() == 1) and
+              (out_READ_UNIT_IN_ACK->read() == 1))
+            {
+              LABEL("Accepted READ_UNIT_IN  number : %d",request_in);
+              request_in  ++;
+            }
+          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+            {
+              LABEL("Test     READ_UNIT_OUT %d : %d,%d",i,out_READ_UNIT_OUT_VAL[i]->read(),in_READ_UNIT_OUT_ACK[i]->read());
+              if ((out_READ_UNIT_OUT_VAL [i]->read() == 1) and
+                  ( in_READ_UNIT_OUT_ACK [i]->read() == 1))
+                {
+                  Tpacket_t  packet_id;
+                  if (_param->_have_port_rob_ptr)
+                    packet_id = out_READ_UNIT_OUT_PACKET_ID [i]->read();
+                  else
+                    packet_id = 0;
+                  LABEL("Accepted READ_UNIT_OUT [%d] number : %d, request number : %d",i,packet_id,request_out);
+                  TEST(bool, request_out_wait [packet_id] , true);
+                  request_out ++;
+                  request_out_wait [packet_id] = false;
+                  Tcontext_t ooo_engine_id = _ooo_engine_id [packet_id];
+                  if (_param->_have_port_context_id)
+                  TEST(Tcontext_t        ,out_READ_UNIT_OUT_CONTEXT_ID   [i]->read(),(2*ooo_engine_id)%_param->_nb_context  );
+                  if (_param->_have_port_front_end_id)
+                  TEST(Tcontext_t        ,out_READ_UNIT_OUT_FRONT_END_ID [i]->read(),(3*ooo_engine_id)%_param->_nb_front_end);
+                  if (_param->_have_port_ooo_engine_id)
+                  TEST(Tcontext_t        ,out_READ_UNIT_OUT_OOO_ENGINE_ID[i]->read(),ooo_engine_id);
+                  if (_read_ra [packet_id])
+                  TEST(Tgeneral_data_t   ,out_READ_UNIT_OUT_DATA_RA   [i]->read(),_gpr[_num_reg_ra[packet_id]][ooo_engine_id]);
+                  if (_read_rb [packet_id])
+                  TEST(Tgeneral_data_t   ,out_READ_UNIT_OUT_DATA_RB   [i]->read(),_gpr[_num_reg_rb[packet_id]][ooo_engine_id]);
+                  if (_read_rc [packet_id])
+                  TEST(Tspecial_data_t   ,out_READ_UNIT_OUT_DATA_RC   [i]->read(),_spr[_num_reg_rc[packet_id]][ooo_engine_id]);
+                }
+            }
+          SC_START(1);
+          for (list<write_req_t>::iterator it = write_req_gpr.begin();
+               it != write_req_gpr.end();
+               )
+            {
+              if (_gpr_val [(*it).reg][(*it).ooo] == 1)
+                it = write_req_gpr.erase(it);
+              else
+                it ++;
+            }
+          for (list<write_req_t>::iterator it = write_req_spr.begin();
+               it != write_req_spr.end();
+               )
+            {
+              if (_spr_val [(*it).reg][(*it).ooo] == 1)
+                it = write_req_spr.erase(it);
+              else
+                it ++;
+            }
+        }
+      for (uint32_t i=0; i<nb_request; i++)
+        TEST(bool, request_out_wait [i] , false);
+    }
+  }
   /********************************************************

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t    _size_read_queue         ;
   public : const uint32_t    _size_reservation_station;
   public : const uint32_t    _nb_context              ;
   public : const uint32_t    _nb_front_end            ;
   public : const uint32_t    _nb_ooo_engine           ;
   public : const uint32_t    _nb_packet               ;
   public : const uint32_t    _size_general_data       ;
   public : const uint32_t    _size_special_data       ;
   public : const uint32_t    _nb_general_register     ;
   public : const uint32_t    _nb_special_register     ;
   public : const uint32_t    _nb_gpr_write            ;
   public : const uint32_t    _nb_spr_write            ;
   public : const uint32_t    _size_store_queue        ;
   public : const uint32_t    _size_load_queue         ;
   public : const uint32_t    _nb_inst_retire          ;
   public : const uint32_t    _nb_bypass_write         ;
   public : const uint32_t    _nb_bypass_memory        ;
   public : const uint32_t    _nb_gpr_read             ;
   public : const uint32_t    _nb_spr_read             ;
   public : const uint32_t    _size_context_id         ;
   public : const uint32_t    _size_front_end_id       ;
   public : const uint32_t    _size_ooo_engine_id      ;
   public : const uint32_t    _size_packet_id          ;
   public : const uint32_t    _size_general_register   ;
   public : const uint32_t    _size_special_register   ;
+  public : uint32_t    _size_read_queue         ;
+  public : uint32_t    _size_reservation_station;
+  public : uint32_t    _nb_context              ;
+  public : uint32_t    _nb_front_end            ;
+  public : uint32_t    _nb_ooo_engine           ;
+  public : uint32_t    _nb_packet               ;
+//public : uint32_t    _size_general_data       ;
+//public : uint32_t    _size_special_data       ;
+  public : uint32_t    _nb_general_register     ;
+  public : uint32_t    _nb_special_register     ;
+  public : uint32_t    _nb_gpr_write            ;
+  public : uint32_t    _nb_spr_write            ;
+//public : uint32_t    _size_store_queue        ;
+//public : uint32_t    _size_load_queue         ;
+  public : uint32_t    _nb_inst_retire          ;
+  public : uint32_t    _nb_bypass_write         ;
+  public : uint32_t    _nb_bypass_memory        ;
+  public : uint32_t    _nb_gpr_read             ;
+  public : uint32_t    _nb_spr_read             ;
+//public : uint32_t    _size_context_id         ;
+//public : uint32_t    _size_front_end_id       ;
+//public : uint32_t    _size_ooo_engine_id      ;
+//public : uint32_t    _size_packet_id          ;
+//public : uint32_t    _size_general_register   ;
+//public : uint32_t    _size_special_register   ;
   public : const bool        _have_port_context_id    ;
   public : const bool        _have_port_front_end_id  ;
   public : const bool        _have_port_ooo_engine_id ;
   public : const bool        _have_port_packet_id     ;
   public : const bool        _have_port_load_queue_ptr;
+//public : bool        _have_port_context_id    ;
+//public : bool        _have_port_front_end_id  ;
+//public : bool        _have_port_ooo_engine_id ;
+//public : bool        _have_port_packet_id     ;
+//public : bool        _have_port_load_queue_ptr;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue         ::Parameters * _param_read_queue;
 …
                         uint32_t nb_inst_retire          ,
                         uint32_t nb_bypass_write         ,
+                        uint32_t nb_bypass_memory        );
+  public : Parameters  (Parameters & param) ;
+                        uint32_t nb_bypass_memory        ,
+                        bool     is_toplevel=false);
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Parameters.cpp

-              r81
+              r88
 #define FUNCTION "Read_unit::Parameters"
   Parameters::Parameters (uint32_t size_read_queue         ,
+                          uint32_t size_reservation_station,
+                          uint32_t nb_context              ,
+                          uint32_t nb_front_end            ,
+                          uint32_t nb_ooo_engine           ,
+                          uint32_t nb_packet               ,
+                          uint32_t size_general_data       ,
+                          uint32_t size_special_data       ,
+                          uint32_t nb_general_register     ,
+                          uint32_t nb_special_register     ,
+                          uint32_t nb_gpr_write            ,
+                          uint32_t nb_spr_write            ,
+                          uint32_t size_store_queue        ,
+                          uint32_t size_load_queue         ,
+                          uint32_t nb_inst_retire          ,
+                          uint32_t nb_bypass_write         ,
+                          uint32_t nb_bypass_memory        ):
+    _size_read_queue          (size_read_queue         ),
+    _size_reservation_station (size_reservation_station),
+    _nb_context               (nb_context              ),
+    _nb_front_end             (nb_front_end            ),
+    _nb_ooo_engine            (nb_ooo_engine           ),
+    _nb_packet                (nb_packet               ),
+    _size_general_data        (size_general_data       ),
+    _size_special_data        (size_special_data       ),
+    _nb_general_register      (nb_general_register     ),
+    _nb_special_register      (nb_special_register     ),
+    _nb_gpr_write             (nb_gpr_write            ),
+    _nb_spr_write             (nb_spr_write            ),
+    _size_store_queue         (size_store_queue        ),
+    _size_load_queue          (size_load_queue         ),
+    _nb_inst_retire           (nb_inst_retire          ),
+    _nb_bypass_write          (nb_bypass_write         ),
+    _nb_bypass_memory         (nb_bypass_memory        ),
+    _nb_gpr_read              (2),
+    _nb_spr_read              (1),
+    _size_context_id          (log2(nb_context         )),
+    _size_front_end_id        (log2(nb_front_end       )),
+    _size_ooo_engine_id       (log2(nb_ooo_engine      )),
+    _size_packet_id           (log2(nb_packet          )),
+    _size_general_register    (log2(nb_general_register)),
+    _size_special_register    (log2(nb_special_register)),
+    _have_port_context_id     (_size_context_id   >0),
+    _have_port_front_end_id   (_size_front_end_id >0),
+    _have_port_ooo_engine_id  (_size_ooo_engine_id>0),
+    _have_port_packet_id      (_size_packet_id    >0),
+    _have_port_load_queue_ptr (_size_load_queue   >1)
+                          uint32_t size_reservation_station,
+                          uint32_t nb_context              ,
+                          uint32_t nb_front_end            ,
+                          uint32_t nb_ooo_engine           ,
+                          uint32_t nb_packet               ,
+                          uint32_t size_general_data       ,
+                          uint32_t size_special_data       ,
+                          uint32_t nb_general_register     ,
+                          uint32_t nb_special_register     ,
+                          uint32_t nb_gpr_write            ,
+                          uint32_t nb_spr_write            ,
+                          uint32_t size_store_queue        ,
+                          uint32_t size_load_queue         ,
+                          uint32_t nb_inst_retire          ,
+                          uint32_t nb_bypass_write         ,
+                          uint32_t nb_bypass_memory        ,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Read_unit,FUNCTION,"Begin");
+    _size_read_queue          = size_read_queue         ;
+    _size_reservation_station = size_reservation_station;
+    _nb_context               = nb_context              ;
+    _nb_front_end             = nb_front_end            ;
+    _nb_ooo_engine            = nb_ooo_engine           ;
+    _nb_packet                = nb_packet               ;
+    _nb_general_register      = nb_general_register     ;
+    _nb_special_register      = nb_special_register     ;
+    _nb_gpr_write             = nb_gpr_write            ;
+    _nb_spr_write             = nb_spr_write            ;
+    _nb_inst_retire           = nb_inst_retire          ;
+    _nb_bypass_write          = nb_bypass_write         ;
+    _nb_bypass_memory         = nb_bypass_memory        ;
+    _nb_gpr_read              = 2;
+    _nb_spr_read              = 1;
     _param_read_queue = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue::Parameters
       ( _size_read_queue
         ,_nb_context
         ,_nb_front_end
         ,_nb_ooo_engine
         ,_nb_packet
         ,_size_general_data
         ,_size_special_data
         ,_nb_general_register
         ,_nb_special_register
         ,_nb_gpr_write
         ,_nb_spr_write
         ,_size_store_queue
         ,_size_load_queue
         );
+      (_size_read_queue
+      ,_nb_context
+      ,_nb_front_end
+      ,_nb_ooo_engine
+      ,_nb_packet
+      , size_general_data
+      , size_special_data
+      ,_nb_general_register
+      ,_nb_special_register
+      ,_nb_gpr_write
+      ,_nb_spr_write
+      , size_store_queue
+      , size_load_queue
+      );
     _param_reservation_station = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::reservation_station::Parameters
+        (size_reservation_station
+         ,nb_inst_retire
+         ,nb_context
+         ,nb_front_end
+         ,nb_ooo_engine
+         ,nb_packet
+         ,size_general_data
+         ,size_special_data
+         ,nb_general_register
+         ,nb_special_register
+         ,nb_gpr_write
+         ,nb_spr_write
+         ,nb_bypass_write
+         ,nb_bypass_memory
+         ,size_store_queue
+         ,size_load_queue
+         );
+        (_size_reservation_station
+        ,_nb_inst_retire
+        ,_nb_context
+        ,_nb_front_end
+        ,_nb_ooo_engine
+        ,_nb_packet
+        , size_general_data
+        , size_special_data
+        ,_nb_general_register
+        ,_nb_special_register
+        ,_nb_gpr_write
+        ,_nb_spr_write
+        ,_nb_bypass_write
+        ,_nb_bypass_memory
+        , size_store_queue
+        , size_load_queue
+        );
     test();
+    if (is_toplevel)
+      {
+        _size_context_id          = log2(nb_context         );
+        _size_front_end_id        = log2(nb_front_end       );
+        _size_ooo_engine_id       = log2(nb_ooo_engine      );
+        _size_rob_ptr             = log2(nb_packet          );
+        _size_general_register    = log2(nb_general_register);
+        _size_special_register    = log2(nb_special_register);
+        _size_general_data        = size_general_data       ;
+        _size_special_data        = size_special_data       ;
+        _size_store_queue_ptr     = log2(size_store_queue   );
+        _size_load_queue_ptr      = log2(size_load_queue    );
+        _have_port_context_id     = _size_context_id     > 0;
+        _have_port_front_end_id   = _size_front_end_id   > 0;
+        _have_port_ooo_engine_id  = _size_ooo_engine_id  > 0;
+        _have_port_rob_ptr        = _size_rob_ptr        > 0;
+        _have_port_load_queue_ptr = _size_load_queue_ptr > 0;
+        copy();
+      }
     log_printf(FUNC,Read_unit,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Read_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_read_queue          (param._size_read_queue         ),
+//     _size_reservation_station (param._size_reservation_station),
+//     _nb_context               (param._nb_context              ),
+//     _nb_front_end             (param._nb_front_end            ),
+//     _nb_ooo_engine            (param._nb_ooo_engine           ),
+//     _nb_packet                (param._nb_packet               ),
+//     _size_general_data        (param._size_general_data       ),
+//     _size_special_data        (param._size_special_data       ),
+//     _nb_general_register      (param._nb_general_register     ),
+//     _nb_special_register      (param._nb_special_register     ),
+//     _nb_gpr_write             (param._nb_gpr_write            ),
+//     _nb_spr_write             (param._nb_spr_write            ),
+//     _size_store_queue         (param._size_store_queue        ),
+//     _size_load_queue          (param._size_load_queue         ),
+//     _nb_inst_retire           (param._nb_inst_retire          ),
+//     _nb_bypass_write          (param._nb_bypass_write         ),
+//     _nb_bypass_memory         (param._nb_bypass_memory        ),
+//     _nb_gpr_read              (param._nb_gpr_read             ),
+//     _nb_spr_read              (param._nb_spr_read             ),
+//     _size_context_id          (param._size_context_id         ),
+//     _size_front_end_id        (param._size_front_end_id       ),
+//     _size_ooo_engine_id       (param._size_ooo_engine_id      ),
+//     _size_packet_id           (param._size_packet_id          ),
+//     _size_general_register    (param._size_general_register   ),
+//     _size_special_register    (param._size_special_register   ),
+//     _have_port_context_id     (param._have_port_context_id    ),
+//     _have_port_front_end_id   (param._have_port_front_end_id  ),
+//     _have_port_ooo_engine_id  (param._have_port_ooo_engine_id ),
+//     _have_port_packet_id      (param._have_port_packet_id     ),
+//     _have_port_load_queue_ptr (param._have_port_load_queue_ptr)
+//   {
+//     log_printf(FUNC,Read_unit,FUNCTION,"Begin");
+//     _param_read_queue          = param._param_read_queue         ;
+//     _param_reservation_station = param._param_reservation_station;
+//     test();
+//     log_printf(FUNC,Read_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Read_unit::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _size_read_queue          (param._size_read_queue         ),
+    _size_reservation_station (param._size_reservation_station),
+    _nb_context               (param._nb_context              ),
+    _nb_front_end             (param._nb_front_end            ),
+    _nb_ooo_engine            (param._nb_ooo_engine           ),
+    _nb_packet                (param._nb_packet               ),
+    _size_general_data        (param._size_general_data       ),
+    _size_special_data        (param._size_special_data       ),
+    _nb_general_register      (param._nb_general_register     ),
+    _nb_special_register      (param._nb_special_register     ),
+    _nb_gpr_write             (param._nb_gpr_write            ),
+    _nb_spr_write             (param._nb_spr_write            ),
+    _size_store_queue         (param._size_store_queue        ),
+    _size_load_queue          (param._size_load_queue         ),
+    _nb_inst_retire           (param._nb_inst_retire          ),
+    _nb_bypass_write          (param._nb_bypass_write         ),
+    _nb_bypass_memory         (param._nb_bypass_memory        ),
+    _nb_gpr_read              (param._nb_gpr_read             ),
+    _nb_spr_read              (param._nb_spr_read             ),
+    _size_context_id          (param._size_context_id         ),
+    _size_front_end_id        (param._size_front_end_id       ),
+    _size_ooo_engine_id       (param._size_ooo_engine_id      ),
+    _size_packet_id           (param._size_packet_id          ),
+    _size_general_register    (param._size_general_register   ),
+    _size_special_register    (param._size_special_register   ),
+    _have_port_context_id     (param._have_port_context_id    ),
+    _have_port_front_end_id   (param._have_port_front_end_id  ),
+    _have_port_ooo_engine_id  (param._have_port_ooo_engine_id ),
+    _have_port_packet_id      (param._have_port_packet_id     ),
+    _have_port_load_queue_ptr (param._have_port_load_queue_ptr)
+#define FUNCTION "Read_unit::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Read_unit,FUNCTION,"Begin");
+    _param_read_queue          = param._param_read_queue         ;
+    _param_reservation_station = param._param_reservation_station;
+    test();
+    delete _param_read_queue;
+    delete _param_reservation_station;
     log_printf(FUNC,Read_unit,FUNCTION,"End");
 …
 #undef  FUNCTION
 #define FUNCTION "Read_unit::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Read_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Read_unit,FUNCTION,"Begin");
     delete _param_read_queue;
     delete _param_reservation_station;
+    COPY(_param_read_queue);
+    COPY(_param_reservation_station);
     log_printf(FUNC,Read_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Parameters_print.cpp

-              r81
+              r88
     xml.singleton_begin("nb_gpr_write            "); xml.attribut("value",toString(_nb_gpr_write            )); xml.singleton_end();
     xml.singleton_begin("nb_spr_write            "); xml.attribut("value",toString(_nb_spr_write            )); xml.singleton_end();
     xml.singleton_begin("size_store_queue        "); xml.attribut("value",toString(_size_store_queue        )); xml.singleton_end();
     xml.singleton_begin("size_load_queue         "); xml.attribut("value",toString(_size_load_queue         )); xml.singleton_end();
+//  xml.singleton_begin("size_store_queue        "); xml.attribut("value",toString(_size_store_queue        )); xml.singleton_end();
+//  xml.singleton_begin("size_load_queue         "); xml.attribut("value",toString(_size_load_queue         )); xml.singleton_end();
     xml.singleton_begin("nb_inst_retire          "); xml.attribut("value",toString(_nb_inst_retire          )); xml.singleton_end();
     xml.singleton_begin("nb_bypass_write         "); xml.attribut("value",toString(_nb_bypass_write         )); xml.singleton_end();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Read_unit,FUNCTION,"Begin");
+#if DEBUG_Read_unit == true
+    log_printf(INFO,Read_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Read_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Read_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Read_unit,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Read_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_allocation.cpp

-              r82
+              r88
                                                          ,IN
                                                          ,SOUTH,
                                                          "Generalist interface"
+                                                         _("Generalist interface")
 #endif
                                                          );
 …
     // ~~~~~[ Interface "read_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC_INTERFACE("read_unit_in", IN, WEST, "Enter of new operation");
+       ALLOC_INTERFACE("read_unit_in", IN, WEST, _("Enter of new operation"));
        ALLOC_VALACK_IN    ( in_READ_UNIT_IN_VAL,VAL);
 …
        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_packet_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        ,log2(_param->_size_store_queue));
        ALLOC_SIGNAL_IN ( in_READ_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
+       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);
 …
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("read_unit_out", OUT, EAST, "Output of operation. All operand is valid.", _param->_nb_inst_retire);
+       ALLOC1_INTERFACE("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);
 …
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id    );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id   );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_packet_id       );
+       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr       );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation       );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_TYPE                 ,"type"                 ,Ttype_t           ,_param->_size_type            );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue ));
+       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t        ,_param->_size_store_queue_ptr);
+       ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr);
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_HAS_IMMEDIAT         ,"has_immediat"         ,Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_OUT(out_READ_UNIT_OUT_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data    );
 …
     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("gpr_read", OUT, SOUTH, "Read port.", _param->_nb_gpr_read);
+       ALLOC1_INTERFACE("gpr_read", OUT, SOUTH, _("Read port."), _param->_nb_gpr_read);
        ALLOC1_VALACK_OUT   (out_GPR_READ_VAL,VAL);
 …
     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("spr_read", OUT, SOUTH, "Read port.", _param->_nb_spr_read);
+       ALLOC1_INTERFACE("spr_read", OUT, SOUTH, _("Read port."), _param->_nb_spr_read);
        ALLOC1_VALACK_OUT   (out_SPR_READ_VAL,VAL);
 …
     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("gpr_write", IN , SOUTH, "Write port.", _param->_nb_gpr_write);
+       ALLOC1_INTERFACE("gpr_write", IN , SOUTH, _("Write port."), _param->_nb_gpr_write);
        ALLOC1_VALACK_IN    ( in_GPR_WRITE_VAL,VAL);
 …
     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("spr_write", IN , SOUTH, "Write port.", _param->_nb_spr_write);
+       ALLOC1_INTERFACE("spr_write", IN , SOUTH, _("Write port."), _param->_nb_spr_write);
        ALLOC1_VALACK_IN    ( in_SPR_WRITE_VAL,VAL);
 …
     // ~~~~~[ Interface "bypass_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("bypass_write", IN , NORTH, "Output of write_queue.", _param->_nb_bypass_write);
+       ALLOC1_INTERFACE("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   );
 …
     // ~~~~~[ Interface "bypass_memory" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("bypass_memory", IN , NORTH, "Output of write_queue.", _param->_nb_bypass_memory);
+       ALLOC1_INTERFACE("bypass_memory", IN , NORTH, _("Output of write_queue."), _param->_nb_bypass_memory);
        ALLOC1_SIGNAL_IN ( in_BYPASS_MEMORY_VAL          ,"val"          ,Tcontrol_t        ,1);
 …
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      std::string name;
+     {
        name = _name+"_read_queue";
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_read_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue::Read_queue
 …
+     {
        name = _name+"_reservation_station";
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_reservation_station  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::reservation_station::Reservation_station
          (name.c_str()
 …
+     {
        name = _name+"_read_queue";
+       std::cout << "Instance : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),name.c_str());
+       {
 #ifdef POSITION
 …
          if (_param->_have_port_ooo_engine_id)
          _component->port_map(name, "in_READ_QUEUE_IN_OOO_ENGINE_ID"        ,dest, "in_READ_UNIT_IN_OOO_ENGINE_ID"        );
          if (_param->_have_port_packet_id)
+         if (_param->_have_port_rob_ptr)
          _component->port_map(name, "in_READ_QUEUE_IN_ROB_ID"               ,dest, "in_READ_UNIT_IN_PACKET_ID"            );
          _component->port_map(name, "in_READ_QUEUE_IN_OPERATION"            ,dest, "in_READ_UNIT_IN_OPERATION"            );
 …
          if (_param->_have_port_ooo_engine_id)
          _component->port_map(name,"out_READ_QUEUE_OUT_OOO_ENGINE_ID"        ,dest, "in_INSERT_OOO_ENGINE_ID"        );
          if (_param->_have_port_packet_id)
+         if (_param->_have_port_rob_ptr)
          _component->port_map(name,"out_READ_QUEUE_OUT_ROB_ID"               ,dest, "in_INSERT_ROB_ID"               );
          _component->port_map(name,"out_READ_QUEUE_OUT_OPERATION"            ,dest, "in_INSERT_OPERATION"            );
 …
+     {
        name = _name+"_reservation_station";
        std::cout << "Instance : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),name.c_str());
+       {
 #ifdef POSITION
 …
          if (_param->_have_port_ooo_engine_id)
          _component->port_map(name, "in_INSERT_OOO_ENGINE_ID"        ,dest,"out_READ_QUEUE_OUT_OOO_ENGINE_ID"        );
          if (_param->_have_port_packet_id)
+         if (_param->_have_port_rob_ptr)
          _component->port_map(name, "in_INSERT_ROB_ID"               ,dest,"out_READ_QUEUE_OUT_ROB_ID"               );
          _component->port_map(name, "in_INSERT_OPERATION"            ,dest,"out_READ_QUEUE_OUT_OPERATION"            );
 …
            if (_param->_have_port_ooo_engine_id)
            _component->port_map(name,"out_RETIRE_"+toString(i)+"_OOO_ENGINE_ID"        ,dest,"out_READ_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID"        );
            if (_param->_have_port_packet_id)
+           if (_param->_have_port_rob_ptr)
            _component->port_map(name,"out_RETIRE_"+toString(i)+"_ROB_ID"               ,dest,"out_READ_UNIT_OUT_"+toString(i)+"_PACKET_ID"            );
            _component->port_map(name,"out_RETIRE_"+toString(i)+"_OPERATION"            ,dest,"out_READ_UNIT_OUT_"+toString(i)+"_OPERATION"            );
 …
+     }
+#ifdef POSITION
+    _component->generate_file();
+#if DEBUG_Read_unit == true
+     _component->test_map();
+#endif
+#ifdef POSITION
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Read_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete     in_READ_UNIT_IN_OOO_ENGINE_ID        ;
         if (_param->_have_port_packet_id)
+        if (_param->_have_port_rob_ptr)
         delete     in_READ_UNIT_IN_PACKET_ID            ;
         delete     in_READ_UNIT_IN_OPERATION            ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete [] out_READ_UNIT_OUT_OOO_ENGINE_ID        ;
         if (_param->_have_port_packet_id)
+        if (_param->_have_port_rob_ptr)
         delete [] out_READ_UNIT_OUT_PACKET_ID            ;
         delete [] out_READ_UNIT_OUT_OPERATION            ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/src/Read_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/Makefile

r81	r88
24	24	library_clean : Execute_queue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/configuration.cfg

-              r81
+              r88
 Execute_queue
        8       *2 # uint32_t size_queue
+       16      *2 # uint32_t size_queue
        1       *2 # uint32_t nb_context
        1       *2 # uint32_t nb_front_end
        4       *2 # uint32_t nb_ooo_engine
       32      *2 # uint32_t nb_packet
+      64      *2 # uint32_t nb_packet
       32      *2 # uint32_t size_general_data
        2       *2 # uint32_t size_special_data

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/src/main.cpp

-              r81
+              r88
          nb_packet          ,
          size_general_data  ,
+         size_special_data  );
+         size_special_data  ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/SelfTest/src/test.cpp

-              r82
+              r88
  */
 #define NB_ITERATION  1
+#define NB_ITERATION  16
 #define CYCLE_MAX     (128*NB_ITERATION)
 …
   public  : Tcontrol_t         _no_sequence  ;
   public  : Tgeneral_data_t    _address      ;
+  public  : Tgeneral_data_t    _data         ;
   public  : entry_t (Tcontext_t         context_id   ,
 …
                      Texception_t       exception    ,
                      Tcontrol_t         no_sequence  ,
+                     Tgeneral_data_t    address      )
+                     Tgeneral_data_t    address      ,
+                     Tgeneral_data_t    data         )
+    {
       _context_id    = context_id   ;
 …
       _no_sequence   = no_sequence  ;
       _address       = address      ;
+      _data          = data         ;
     };
 …
                     << " * _exception     : " << toString(x._exception    ) << std::endl
                     << " * _no_sequence   : " << toString(x._no_sequence  ) << std::endl
+                    << " * _address       : " << toString(x._address      ) << std::endl;
+                    << " * _address       : " << toString(x._address      ) << std::endl
+                    << " * _data          : " << toString(x._data         ) << std::endl;
       return output_stream;
 …
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Execute_queue * _Execute_queue = new Execute_queue
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   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"       , Tgeneral_data_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_NO_SEQUENCE  ,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , Tcontrol_t        );
   ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_ADDRESS      ,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , Tgeneral_data_t   );
+  ALLOC_SC_SIGNAL (out_EXECUTE_QUEUE_OUT_DATA         ,"out_EXECUTE_QUEUE_OUT_DATA"         , Tgeneral_data_t   );
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Execute_queue,  in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID );
   if (_param->_have_port_packet_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_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          );
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_packet_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_NO_SEQUENCE  );
   INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_ADDRESS      );
+  INSTANCE_SC_SIGNAL (_Execute_queue, out_EXECUTE_QUEUE_OUT_DATA         );
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
                                      range<Texception_t      >(rand(),_param->_size_exception       ),
                                      range<Tcontrol_t        >(rand(),1                             ),
+                                     range<Tgeneral_data_t   >(rand(),_param->_size_general_data    ),
                                      range<Tgeneral_data_t   >(rand(),_param->_size_general_data    ));
+        }
 …
             in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ->write(request [nb_request_in]->_no_sequence  );
             in_EXECUTE_QUEUE_IN_ADDRESS      ->write(request [nb_request_in]->_address      );
+            in_EXECUTE_QUEUE_IN_DATA         ->write(request [nb_request_in]->_data         );
+          }
         in_EXECUTE_QUEUE_OUT_ACK         ->write((rand()%100)<percent_transaction_execute_queue_out);
 …
+          {
             Tcontext_t packet;
             if (_param->_have_port_packet_id)
+            if (_param->_have_port_rob_ptr)
               packet = out_EXECUTE_QUEUE_OUT_PACKET_ID->read();
             else
 …
             TEST(Tcontrol_t     , out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ->read(), request [packet]->_no_sequence  );
             TEST(Tgeneral_data_t, out_EXECUTE_QUEUE_OUT_ADDRESS      ->read(), request [packet]->_address      );
+            TEST(Tgeneral_data_t, out_EXECUTE_QUEUE_OUT_DATA         ->read(), request [packet]->_data         );
             nb_request_out ++;
 …
   delete     in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ;
   delete     in_EXECUTE_QUEUE_IN_ADDRESS       ;
+  delete     in_EXECUTE_QUEUE_IN_DATA          ;
   delete    out_EXECUTE_QUEUE_OUT_VAL          ;
 …
   delete    out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ;
   delete    out_EXECUTE_QUEUE_OUT_ADDRESS      ;
+  delete    out_EXECUTE_QUEUE_OUT_DATA         ;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/include/Execute_queue.h

-              r82
+              r88
   public    : SC_IN (Tcontrol_t        )    *  in_EXECUTE_QUEUE_IN_NO_SEQUENCE   ;
   public    : SC_IN (Tgeneral_data_t   )    *  in_EXECUTE_QUEUE_IN_ADDRESS       ;
+  public    : SC_IN (Tgeneral_data_t   )    *  in_EXECUTE_QUEUE_IN_DATA          ;
     // -----[ Interface "Execute_queue_out" ]-----------------------------
 …
   public    : SC_OUT(Tcontrol_t        )    * out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  ;
   public    : SC_OUT(Tgeneral_data_t   )    * out_EXECUTE_QUEUE_OUT_ADDRESS      ;
+  public    : SC_OUT(Tgeneral_data_t   )    * out_EXECUTE_QUEUE_OUT_DATA         ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t            _size_queue                   ;
   public : const uint32_t            _nb_context                   ;
   public : const uint32_t            _nb_front_end                 ;
   public : const uint32_t            _nb_ooo_engine                ;
   public : const uint32_t            _nb_packet                    ;
   public : const uint32_t            _size_general_data            ;
   public : const uint32_t            _size_special_data            ;
+  public : uint32_t            _size_queue                   ;
+  public : uint32_t            _nb_context                   ;
+  public : uint32_t            _nb_front_end                 ;
+  public : uint32_t            _nb_ooo_engine                ;
+  public : uint32_t            _nb_packet                    ;
+//public : uint32_t            _size_general_data            ;
+//public : uint32_t            _size_special_data            ;
   public : const uint32_t            _size_context_id              ;
   public : const uint32_t            _size_front_end_id            ;
   public : const uint32_t            _size_ooo_engine_id           ;
   public : const uint32_t            _size_packet_id               ;
+//public : uint32_t            _size_context_id              ;
+//public : uint32_t            _size_front_end_id            ;
+//public : uint32_t            _size_ooo_engine_id           ;
+//public : uint32_t            _size_packet_id               ;
   public : const bool                _have_port_context_id         ;
   public : const bool                _have_port_front_end_id       ;
   public : const bool                _have_port_ooo_engine_id      ;
   public : const bool                _have_port_packet_id          ;
+//public : bool                _have_port_context_id         ;
+//public : bool                _have_port_front_end_id       ;
+//public : bool                _have_port_ooo_engine_id      ;
+//public : bool                _have_port_packet_id          ;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t nb_packet          ,
                         uint32_t size_general_data  ,
+                        uint32_t size_special_data  );
+  public : Parameters  (Parameters & param) ;
+                        uint32_t size_special_data  ,
+                        bool     is_toplevel=true);
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/include/Types.h

-              r82
+              r88
   public  : Tcontrol_t         _no_sequence  ;
   public  : Tgeneral_data_t    _address      ;
+  public  : Tgeneral_data_t    _data         ;
   public  : execute_queue_entry_t (Tcontext_t         context_id   ,
 …
                                    Texception_t       exception    ,
                                    Tcontrol_t         no_sequence  ,
+                                   Tgeneral_data_t    address      )
+                                   Tgeneral_data_t    address      ,
+                                   Tgeneral_data_t    data         )
+    {
       _context_id    = context_id   ;
 …
       _no_sequence   = no_sequence  ;
       _address       = address      ;
+      _data          = data         ;
     };
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue.cpp

-              r81
+              r88
     log_printf(FUNC,Execute_queue,FUNCTION,"Begin");
+#if DEBUG_Execute_queue == true
+    log_printf(INFO,Execute_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Execute_queue,FUNCTION,"Allocation");
     allocation ();
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Execute_queue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Execute_queue,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Execute_queue,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_allocation.cpp

-              r81
+              r88
 namespace write_unit {
 namespace execute_queue {
 #undef  FUNCTION
 …
        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_packet_id)
        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_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_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                              );
        ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data     );
+       ALLOC_SIGNAL_IN ( in_EXECUTE_QUEUE_IN_DATA         ,"data"         ,Tgeneral_data_t   ,_param->_size_general_data     );
+     }
 …
        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_packet_id)
        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_packet_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_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
        ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_general_data );
+       ALLOC_SIGNAL_OUT(out_EXECUTE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+     }
 …
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Execute_queue,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete      in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID;
         if (_param->_have_port_packet_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_NO_SEQUENCE  ;
         delete      in_EXECUTE_QUEUE_IN_ADDRESS      ;
+        delete      in_EXECUTE_QUEUE_IN_DATA         ;
         // -----[ Interface "execute_queue_out" ]-------------------------------
 …
         if (_param->_have_port_ooo_engine_id)
         delete     out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID;
         if (_param->_have_port_packet_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_NO_SEQUENCE  ;
         delete     out_EXECUTE_QUEUE_OUT_ADDRESS      ;
+        delete     out_EXECUTE_QUEUE_OUT_DATA         ;
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_genMoore.cpp

-              r81
+              r88
           if (_param->_have_port_ooo_engine_id)
           PORT_WRITE(out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID, _queue->front()->_ooo_engine_id);
           if (_param->_have_port_packet_id)
+          if (_param->_have_port_rob_ptr)
           PORT_WRITE(out_EXECUTE_QUEUE_OUT_PACKET_ID    , _queue->front()->_packet_id    );
 //        PORT_WRITE(out_EXECUTE_QUEUE_OUT_OPERATION    , _queue->front()->_operation    );
 …
           PORT_WRITE(out_EXECUTE_QUEUE_OUT_NO_SEQUENCE  , _queue->front()->_no_sequence  );
           PORT_WRITE(out_EXECUTE_QUEUE_OUT_ADDRESS      , _queue->front()->_address      );
+          PORT_WRITE(out_EXECUTE_QUEUE_OUT_DATA         , _queue->front()->_data         );
+        }
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Execute_queue_transition.cpp

-              r81
+              r88
                (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_QUEUE_IN_FRONT_END_ID ):0,
                (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID):0,
                (_param->_have_port_packet_id    )?PORT_READ(in_EXECUTE_QUEUE_IN_PACKET_ID    ):0,
+               (_param->_have_port_rob_ptr      )?PORT_READ(in_EXECUTE_QUEUE_IN_PACKET_ID    ):0,
              //PORT_READ(in_EXECUTE_QUEUE_IN_OPERATION    ),
              //PORT_READ(in_EXECUTE_QUEUE_IN_TYPE         ),
 …
                PORT_READ(in_EXECUTE_QUEUE_IN_EXCEPTION    ),
                PORT_READ(in_EXECUTE_QUEUE_IN_NO_SEQUENCE  ),
+               PORT_READ(in_EXECUTE_QUEUE_IN_ADDRESS      ));
+               PORT_READ(in_EXECUTE_QUEUE_IN_ADDRESS      ),
+               PORT_READ(in_EXECUTE_QUEUE_IN_DATA         ));
             _queue->push(entry);
 …
 #ifdef STATISTICS
+    *(_stat_use_queue) += _queue->size();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      *(_stat_use_queue) += _queue->size();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue/src/Parameters.cpp

-              r81
+              r88
                           uint32_t nb_packet          ,
                           uint32_t size_general_data  ,
+                          uint32_t size_special_data  ):
+    _size_queue              (size_queue         ),
+    _nb_context              (nb_context         ),
+    _nb_front_end            (nb_front_end       ),
+    _nb_ooo_engine           (nb_ooo_engine      ),
+    _nb_packet               (nb_packet          ),
+    _size_general_data       (size_general_data  ),
+    _size_special_data       (size_special_data  ),
+    _size_context_id         (log2(_nb_context         )),
+    _size_front_end_id       (log2(_nb_front_end       )),
+    _size_ooo_engine_id      (log2(_nb_ooo_engine      )),
+    _size_packet_id          (log2(_nb_packet          )),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_packet_id     (_size_packet_id     > 0)
+                          uint32_t size_special_data  ,
+                          bool     is_toplevel        )
+  {
     log_printf(FUNC,Execute_queue,FUNCTION,"Begin");
+    _size_queue              = size_queue         ;
+    _nb_context              = nb_context         ;
+    _nb_front_end            = nb_front_end       ;
+    _nb_ooo_engine           = nb_ooo_engine      ;
+    _nb_packet               = nb_packet          ;
     test();
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(_nb_context   );
+        _size_front_end_id       = log2(_nb_front_end );
+        _size_ooo_engine_id      = log2(_nb_ooo_engine);
+        _size_rob_ptr            = log2(_nb_packet    );
+        _size_general_data       = size_general_data;
+        _size_special_data       = size_special_data;
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        copy();
+      }
     log_printf(FUNC,Execute_queue,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Execute_queue::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_queue              (param._size_queue             ),
+//     _nb_context              (param._nb_context             ),
+//     _nb_front_end            (param._nb_front_end           ),
+//     _nb_ooo_engine           (param._nb_ooo_engine          ),
+//     _nb_packet               (param._nb_packet              ),
+//     _size_general_data       (param._size_general_data      ),
+//     _size_special_data       (param._size_special_data      ),
+//     _size_context_id         (param._size_context_id        ),
+//     _size_front_end_id       (param._size_front_end_id      ),
+//     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+//     _size_packet_id          (param._size_packet_id         ),
+//     _have_port_context_id    (param._have_port_context_id   ),
+//     _have_port_front_end_id  (param._have_port_front_end_id ),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+//     _have_port_packet_id     (param._have_port_packet_id    )
+//   {
+//     log_printf(FUNC,Execute_queue,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Execute_queue,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Execute_queue::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _size_queue              (param._size_queue             ),
+    _nb_context              (param._nb_context             ),
+    _nb_front_end            (param._nb_front_end           ),
+    _nb_ooo_engine           (param._nb_ooo_engine          ),
+    _nb_packet               (param._nb_packet              ),
+    _size_general_data       (param._size_general_data      ),
+    _size_special_data       (param._size_special_data      ),
+    _size_context_id         (param._size_context_id        ),
+    _size_front_end_id       (param._size_front_end_id      ),
+    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+    _size_packet_id          (param._size_packet_id         ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_packet_id     (param._have_port_packet_id    )
+#define FUNCTION "Execute_queue::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Execute_queue,FUNCTION,"Begin");
-    test();
     log_printf(FUNC,Execute_queue,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Execute_queue::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Execute_queue::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Execute_queue,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Write_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/SelfTest/src/main.cpp

-              r81
+              r88
          size_special_data  ,
          nb_special_register,
+         nb_bypass_write    );
+         nb_bypass_write    ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Write_unit * _Write_unit = new Write_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   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"      , Tgeneral_data_t   );
+  ALLOC_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);
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Write_unit,  in_WRITE_UNIT_IN_OOO_ENGINE_ID );
   if (_param->_have_port_packet_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     );
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_packet_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_NO_SEQUENCE  );
   INSTANCE_SC_SIGNAL (_Write_unit, out_WRITE_UNIT_OUT_ADDRESS      );
+  INSTANCE_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);
 …
+          {
             Tcontext_t packet;
             if (_param->_have_port_packet_id)
+            if (_param->_have_port_rob_ptr)
               packet = out_WRITE_UNIT_OUT_PACKET_ID->read();
             else
 …
             TEST(Tcontrol_t     , out_WRITE_UNIT_OUT_NO_SEQUENCE  ->read(), request [packet]->_no_sequence  );
             TEST(Tgeneral_data_t, out_WRITE_UNIT_OUT_ADDRESS      ->read(), request [packet]->_address      );
+            TEST(Tgeneral_data_t, out_WRITE_UNIT_OUT_DATA         ->read(), request [packet]->_data_rd      );
             nb_request_out ++;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/Makefile

r81	r88
24	24	library_clean : Write_queue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/configuration.cfg

r81	r88
9	9	2 2 *2 # uint32_t size_special_data
10	10	16 16 *2 # uint32_t nb_special_register
11		1 8 *2 # uint32_t nb_bypass_write
	11	1 8 *4 # uint32_t nb_bypass_write

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/src/main.cpp

-              r81
+              r88
          size_special_data  ,
          nb_special_register,
+         nb_bypass_write    );
+         nb_bypass_write    ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/src/test.cpp

-              r82
+              r88
 #define NB_ITERATION  1
 #define CYCLE_MAX     (128*NB_ITERATION)
+#define CYCLE_MAX     (1024*NB_ITERATION)
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/SelfTest/include/test.h"
 …
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Write_queue * _Write_queue = new Write_queue
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   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"         , 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);
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Write_queue,  in_WRITE_QUEUE_IN_OOO_ENGINE_ID );
   if (_param->_have_port_packet_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     );
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_OOO_ENGINE_ID);
   if (_param->_have_port_packet_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_NO_SEQUENCE  );
   INSTANCE_SC_SIGNAL (_Write_queue, out_WRITE_QUEUE_OUT_ADDRESS      );
+  INSTANCE_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);
 …
+          {
             Tcontext_t packet;
             if (_param->_have_port_packet_id)
+            if (_param->_have_port_rob_ptr)
               packet = out_WRITE_QUEUE_OUT_PACKET_ID->read();
             else
 …
             TEST(Tcontrol_t     , out_WRITE_QUEUE_OUT_NO_SEQUENCE  ->read(), request [packet]->_no_sequence  );
             TEST(Tgeneral_data_t, out_WRITE_QUEUE_OUT_ADDRESS      ->read(), request [packet]->_address      );
+            TEST(Tgeneral_data_t, out_WRITE_QUEUE_OUT_DATA         ->read(), request [packet]->_data_rd      );
             nb_request_out ++;
 …
   delete    out_WRITE_QUEUE_OUT_NO_SEQUENCE  ;
   delete    out_WRITE_QUEUE_OUT_ADDRESS      ;
+  delete    out_WRITE_QUEUE_OUT_DATA         ;
   delete [] out_GPR_WRITE_VAL                ;
   delete []  in_GPR_WRITE_ACK                ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t            _size_queue                   ;
   public : const uint32_t            _nb_context                   ;
   public : const uint32_t            _nb_front_end                 ;
   public : const uint32_t            _nb_ooo_engine                ;
   public : const uint32_t            _nb_packet                    ;
   public : const uint32_t            _size_general_data            ;
   public : const uint32_t            _nb_general_register          ;
   public : const uint32_t            _size_special_data            ;
   public : const uint32_t            _nb_special_register          ;
   public : const uint32_t            _nb_bypass_write              ;
+  public : uint32_t            _size_queue                   ;
+  public : uint32_t            _nb_context                   ;
+  public : uint32_t            _nb_front_end                 ;
+  public : uint32_t            _nb_ooo_engine                ;
+  public : uint32_t            _nb_packet                    ;
+//public : uint32_t            _size_general_data            ;
+  public : uint32_t            _nb_general_register          ;
+//public : uint32_t            _size_special_data            ;
+  public : uint32_t            _nb_special_register          ;
+  public : uint32_t            _nb_bypass_write              ;
   public : const uint32_t            _nb_gpr_write                 ;
   public : const uint32_t            _nb_spr_write                 ;
+  public : uint32_t            _nb_gpr_write                 ;
+  public : uint32_t            _nb_spr_write                 ;
   public : const uint32_t            _size_context_id              ;
   public : const uint32_t            _size_front_end_id            ;
   public : const uint32_t            _size_ooo_engine_id           ;
   public : const uint32_t            _size_packet_id               ;
   public : const uint32_t            _size_general_register        ;
   public : const uint32_t            _size_special_register        ;
+//public : uint32_t            _size_context_id              ;
+//public : uint32_t            _size_front_end_id            ;
+//public : uint32_t            _size_ooo_engine_id           ;
+//public : uint32_t            _size_packet_id               ;
+//public : uint32_t            _size_general_register        ;
+//public : uint32_t            _size_special_register        ;
   public : const bool                _have_port_context_id         ;
   public : const bool                _have_port_front_end_id       ;
   public : const bool                _have_port_ooo_engine_id      ;
   public : const bool                _have_port_packet_id          ;
+//public : bool                _have_port_context_id         ;
+//public : bool                _have_port_front_end_id       ;
+//public : bool                _have_port_ooo_engine_id      ;
+//public : bool                _have_port_packet_id          ;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t size_special_data  ,
                         uint32_t nb_special_register,
+                        uint32_t nb_bypass_write    );
+  public : Parameters  (Parameters & param) ;
+                        uint32_t nb_bypass_write    ,
+                        bool     is_toplevel=false  );
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string   print      (uint32_t depth);
   public : friend std::ostream& operator<< (std::ostream& output_stream,
                                             morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Parameters & x);
+  public :        std::string     print      (uint32_t depth);
+  public : friend std::ostream&   operator<< (std::ostream& output_stream,
+                                              morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Parameters & x);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/include/Write_queue.h

r82	r88
100	100	public : SC_OUT(Tcontrol_t ) * out_WRITE_QUEUE_OUT_NO_SEQUENCE ;
101	101	public : SC_OUT(Tgeneral_data_t ) * out_WRITE_QUEUE_OUT_ADDRESS ;
	102	public : SC_OUT(Tgeneral_data_t ) * out_WRITE_QUEUE_OUT_DATA ;
102	103
103	104	// -----[ Interface "gpr_write" ]-------------------------------------

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Parameters.cpp

-              r81
+              r88
                           uint32_t size_special_data  ,
                           uint32_t nb_special_register,
+                          uint32_t nb_bypass_write    ):
+    _size_queue              (size_queue         ),
+    _nb_context              (nb_context         ),
+    _nb_front_end            (nb_front_end       ),
+    _nb_ooo_engine           (nb_ooo_engine      ),
+    _nb_packet               (nb_packet          ),
+    _size_general_data       (size_general_data  ),
+    _nb_general_register     (nb_general_register),
+    _size_special_data       (size_special_data  ),
+    _nb_special_register     (nb_special_register),
+    _nb_bypass_write         (nb_bypass_write    ),
+    _nb_gpr_write            (1),
+    _nb_spr_write            (1),
+    _size_context_id         (log2(_nb_context         )),
+    _size_front_end_id       (log2(_nb_front_end       )),
+    _size_ooo_engine_id      (log2(_nb_ooo_engine      )),
+    _size_packet_id          (log2(_nb_packet          )),
+    _size_general_register   (log2(_nb_general_register)),
+    _size_special_register   (log2(_nb_special_register)),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_packet_id     (_size_packet_id     > 0)
+                          uint32_t nb_bypass_write    ,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Write_queue,FUNCTION,"Begin");
+    _size_queue              = size_queue         ;
+    _nb_context              = nb_context         ;
+    _nb_front_end            = nb_front_end       ;
+    _nb_ooo_engine           = nb_ooo_engine      ;
+    _nb_packet               = nb_packet          ;
+    _nb_general_register     = nb_general_register;
+    _nb_special_register     = nb_special_register;
+    _nb_bypass_write         = nb_bypass_write    ;
+    _nb_gpr_write            = 1;
+    _nb_spr_write            = 1;
     test();
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(_nb_context         );
+        _size_front_end_id       = log2(_nb_front_end       );
+        _size_ooo_engine_id      = log2(_nb_ooo_engine      );
+        _size_rob_ptr            = log2(_nb_packet          );
+        _size_general_register   = log2(_nb_general_register);
+        _size_special_register   = log2(_nb_special_register);
+        _size_general_data       = size_general_data  ;
+        _size_special_data       = size_special_data  ;
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        copy();
+      }
     log_printf(FUNC,Write_queue,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Write_queue::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_queue              (param._size_queue             ),
+//     _nb_context              (param._nb_context             ),
+//     _nb_front_end            (param._nb_front_end           ),
+//     _nb_ooo_engine           (param._nb_ooo_engine          ),
+//     _nb_packet               (param._nb_packet              ),
+//     _size_general_data       (param._size_general_data      ),
+//     _nb_general_register     (param._nb_general_register    ),
+//     _size_special_data       (param._size_special_data      ),
+//     _nb_special_register     (param._nb_special_register    ),
+//     _nb_bypass_write         (param._nb_bypass_write        ),
+//     _nb_gpr_write            (param._nb_gpr_write           ),
+//     _nb_spr_write            (param._nb_spr_write           ),
+//     _size_context_id         (param._size_context_id        ),
+//     _size_front_end_id       (param._size_front_end_id      ),
+//     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+//     _size_packet_id          (param._size_packet_id         ),
+//     _size_general_register   (param._size_general_register  ),
+//     _size_special_register   (param._size_special_register  ),
+//     _have_port_context_id    (param._have_port_context_id   ),
+//     _have_port_front_end_id  (param._have_port_front_end_id ),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+//     _have_port_packet_id     (param._have_port_packet_id    )
+//   {
+//     log_printf(FUNC,Write_queue,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Write_queue,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Write_queue::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _size_queue              (param._size_queue             ),
+    _nb_context              (param._nb_context             ),
+    _nb_front_end            (param._nb_front_end           ),
+    _nb_ooo_engine           (param._nb_ooo_engine          ),
+    _nb_packet               (param._nb_packet              ),
+    _size_general_data       (param._size_general_data      ),
+    _nb_general_register     (param._nb_general_register    ),
+    _size_special_data       (param._size_special_data      ),
+    _nb_special_register     (param._nb_special_register    ),
+    _nb_bypass_write         (param._nb_bypass_write        ),
+    _nb_gpr_write            (param._nb_gpr_write           ),
+    _nb_spr_write            (param._nb_spr_write           ),
+    _size_context_id         (param._size_context_id        ),
+    _size_front_end_id       (param._size_front_end_id      ),
+    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+    _size_packet_id          (param._size_packet_id         ),
+    _size_general_register   (param._size_general_register  ),
+    _size_special_register   (param._size_special_register  ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_packet_id     (param._have_port_packet_id    )
+#define FUNCTION "Write_queue::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Write_queue,FUNCTION,"Begin");
-    test();
     log_printf(FUNC,Write_queue,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Write_queue::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Write_queue::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Write_queue,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue.cpp

-              r81
+              r88
     log_printf(FUNC,Write_queue,FUNCTION,"Begin");
+#if DEBUG_Write_queue == true
+    log_printf(INFO,Write_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Write_queue,FUNCTION,"Allocation");
     allocation ();
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Write_queue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Write_queue,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Write_queue,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_allocation.cpp

-              r81
+              r88
        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_packet_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_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_packet_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_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
        ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_general_data );
+       ALLOC_SIGNAL_OUT(out_WRITE_QUEUE_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+     }
 …
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Write_queue,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete      in_WRITE_QUEUE_IN_OOO_ENGINE_ID;
         if (_param->_have_port_packet_id)
+        if (_param->_have_port_rob_ptr  )
         delete      in_WRITE_QUEUE_IN_PACKET_ID    ;
 //      delete      in_WRITE_QUEUE_IN_OPERATION    ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete     out_WRITE_QUEUE_OUT_OOO_ENGINE_ID;
         if (_param->_have_port_packet_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_NO_SEQUENCE  ;
         delete     out_WRITE_QUEUE_OUT_ADDRESS      ;
+        delete     out_WRITE_QUEUE_OUT_DATA         ;
         // -----[ Interface "gpr_write" ]-------------------------------------

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_genMoore.cpp

-              r81
+              r88
           if (_param->_have_port_ooo_engine_id)
           PORT_WRITE(out_WRITE_QUEUE_OUT_OOO_ENGINE_ID, _queue->front()->_ooo_engine_id);
           if (_param->_have_port_packet_id)
+          if (_param->_have_port_rob_ptr  )
           PORT_WRITE(out_WRITE_QUEUE_OUT_PACKET_ID    , _queue->front()->_packet_id    );
 //        PORT_WRITE(out_WRITE_QUEUE_OUT_OPERATION    , _queue->front()->_operation    );
 …
           PORT_WRITE(out_WRITE_QUEUE_OUT_NO_SEQUENCE  , _queue->front()->_no_sequence  );
           PORT_WRITE(out_WRITE_QUEUE_OUT_ADDRESS      , _queue->front()->_address      );
+          PORT_WRITE(out_WRITE_QUEUE_OUT_DATA         , _queue->front()->_data_rd      );
+        }
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue/src/Write_queue_transition.cpp

-              r81
+              r88
                (_param->_have_port_front_end_id )?PORT_READ(in_WRITE_QUEUE_IN_FRONT_END_ID ):0,
                (_param->_have_port_ooo_engine_id)?PORT_READ(in_WRITE_QUEUE_IN_OOO_ENGINE_ID):0,
                (_param->_have_port_packet_id    )?PORT_READ(in_WRITE_QUEUE_IN_PACKET_ID    ):0,
+               (_param->_have_port_rob_ptr      )?PORT_READ(in_WRITE_QUEUE_IN_PACKET_ID    ):0,
              //PORT_READ(in_WRITE_QUEUE_IN_OPERATION    ),
                PORT_READ(in_WRITE_QUEUE_IN_TYPE         ),
 …
 #ifdef STATISTICS
+    *(_stat_use_queue) += _queue->size();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      *(_stat_use_queue) += _queue->size();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t            _size_write_queue             ;
   public : const uint32_t            _size_execute_queue           ;
   public : const uint32_t            _nb_context                   ;
   public : const uint32_t            _nb_front_end                 ;
   public : const uint32_t            _nb_ooo_engine                ;
   public : const uint32_t            _nb_packet                    ;
   public : const uint32_t            _size_general_data            ;
   public : const uint32_t            _nb_general_register          ;
   public : const uint32_t            _size_special_data            ;
   public : const uint32_t            _nb_special_register          ;
   public : const uint32_t            _nb_bypass_write              ;
+  public : uint32_t            _size_write_queue             ;
+  public : uint32_t            _size_execute_queue           ;
+  public : uint32_t            _nb_context                   ;
+  public : uint32_t            _nb_front_end                 ;
+  public : uint32_t            _nb_ooo_engine                ;
+  public : uint32_t            _nb_packet                    ;
+//public : uint32_t            _size_general_data            ;
+  public : uint32_t            _nb_general_register          ;
+//public : uint32_t            _size_special_data            ;
+  public : uint32_t            _nb_special_register          ;
+  public : uint32_t            _nb_bypass_write              ;
   public : const uint32_t            _nb_gpr_write                 ;
   public : const uint32_t            _nb_spr_write                 ;
+  public : uint32_t            _nb_gpr_write                 ;
+  public : uint32_t            _nb_spr_write                 ;
   public : const uint32_t            _size_context_id              ;
   public : const uint32_t            _size_front_end_id            ;
   public : const uint32_t            _size_ooo_engine_id           ;
   public : const uint32_t            _size_packet_id               ;
   public : const uint32_t            _size_general_register        ;
   public : const uint32_t            _size_special_register        ;
+//public : uint32_t            _size_context_id              ;
+//public : uint32_t            _size_front_end_id            ;
+//public : uint32_t            _size_ooo_engine_id           ;
+//public : uint32_t            _size_packet_id               ;
+//public : uint32_t            _size_general_register        ;
+//public : uint32_t            _size_special_register        ;
   public : const bool                _have_component_execute_queue ;
   public : const bool                _have_port_context_id         ;
   public : const bool                _have_port_front_end_id       ;
   public : const bool                _have_port_ooo_engine_id      ;
   public : const bool                _have_port_packet_id          ;
+  public : bool                _have_component_execute_queue ;
+//public : bool                _have_port_context_id         ;
+//public : bool                _have_port_front_end_id       ;
+//public : bool                _have_port_ooo_engine_id      ;
+//public : bool                _have_port_packet_id          ;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue  ::Parameters * _param_write_queue;
 …
                         uint32_t size_special_data  ,
                         uint32_t nb_special_register,
+                        uint32_t nb_bypass_write    );
+  public : Parameters  (Parameters & param) ;
+                        uint32_t nb_bypass_write    ,
+                        bool     is_toplevel=false);
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/include/Write_unit.h

r82	r88
95	95	public : SC_OUT(Tcontrol_t ) * out_WRITE_UNIT_OUT_NO_SEQUENCE ;
96	96	public : SC_OUT(Tgeneral_data_t ) * out_WRITE_UNIT_OUT_ADDRESS ;
	97	public : SC_OUT(Tgeneral_data_t ) * out_WRITE_UNIT_OUT_DATA ;
97	98
98	99	// -----[ Interface "gpr_write" ]-------------------------------------

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t size_special_data  ,
                           uint32_t nb_special_register,
+                          uint32_t nb_bypass_write    ):
+    _size_write_queue        (size_write_queue   ),
+    _size_execute_queue      (size_execute_queue ),
+    _nb_context              (nb_context         ),
+    _nb_front_end            (nb_front_end       ),
+    _nb_ooo_engine           (nb_ooo_engine      ),
+    _nb_packet               (nb_packet          ),
+    _size_general_data       (size_general_data  ),
+    _nb_general_register     (nb_general_register),
+    _size_special_data       (size_special_data  ),
+    _nb_special_register     (nb_special_register),
+    _nb_bypass_write         (nb_bypass_write    ),
+    _nb_gpr_write            (1),
+    _nb_spr_write            (1),
+    _size_context_id         (log2(_nb_context         )),
+    _size_front_end_id       (log2(_nb_front_end       )),
+    _size_ooo_engine_id      (log2(_nb_ooo_engine      )),
+    _size_packet_id          (log2(_nb_packet          )),
+    _size_general_register   (log2(_nb_general_register)),
+    _size_special_register   (log2(_nb_special_register)),
+    _have_component_execute_queue (_size_execute_queue > 0),
+    _have_port_context_id         (_size_context_id    > 0),
+    _have_port_front_end_id       (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id      (_size_ooo_engine_id > 0),
+    _have_port_packet_id          (_size_packet_id     > 0)
+                          uint32_t nb_bypass_write    ,
+                          bool     is_toplevel        )
+  {
     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
+    _param_write_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue  ::Parameters(size_write_queue   ,
+                                                                                                                                                    nb_context         ,
+                                                                                                                                                    nb_front_end       ,
+                                                                                                                                                    nb_ooo_engine      ,
+                                                                                                                                                    nb_packet          ,
+                                                                                                                                                    size_general_data  ,
+                                                                                                                                                    nb_general_register,
+                                                                                                                                                    size_special_data  ,
+                                                                                                                                                    nb_special_register,
+                                                                                                                                                    nb_bypass_write    );
+    _size_write_queue             = size_write_queue   ;
+    _size_execute_queue           = size_execute_queue ;
+    _nb_context                   = nb_context         ;
+    _nb_front_end                 = nb_front_end       ;
+    _nb_ooo_engine                = nb_ooo_engine      ;
+    _nb_packet                    = nb_packet          ;
+    _nb_general_register          = nb_general_register;
+    _nb_special_register          = nb_special_register;
+    _nb_bypass_write              = nb_bypass_write    ;
+    _nb_gpr_write                 = 1;
+    _nb_spr_write                 = 1;
+    _have_component_execute_queue = _size_execute_queue > 0;
+    _param_write_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue  ::Parameters(_size_write_queue   ,
+                                                                                                                                                    _nb_context         ,
+                                                                                                                                                    _nb_front_end       ,
+                                                                                                                                                    _nb_ooo_engine      ,
+                                                                                                                                                    _nb_packet          ,
+                                                                                                                                                     size_general_data  ,
+                                                                                                                                                    _nb_general_register,
+                                                                                                                                                     size_special_data  ,
+                                                                                                                                                    _nb_special_register,
+                                                                                                                                                    _nb_bypass_write    );
     if (_have_component_execute_queue)
       _param_execute_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::execute_queue::Parameters(size_execute_queue   ,
                                                                                                                                                         nb_context         ,
                                                                                                                                                         nb_front_end       ,
                                                                                                                                                         nb_ooo_engine      ,
                                                                                                                                                         nb_packet          ,
                                                                                                                                                         size_general_data  ,
                                                                                                                                                         size_special_data  );
+      _param_execute_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::execute_queue::Parameters(_size_execute_queue   ,
+                                                                                                                                                        _nb_context         ,
+                                                                                                                                                        _nb_front_end       ,
+                                                                                                                                                        _nb_ooo_engine      ,
+                                                                                                                                                        _nb_packet          ,
+                                                                                                                                                         size_general_data  ,
+                                                                                                                                                         size_special_data  );
     test();
+    if (is_toplevel)
+      {
+        _size_context_id              = log2(_nb_context         );
+        _size_front_end_id            = log2(_nb_front_end       );
+        _size_ooo_engine_id           = log2(_nb_ooo_engine      );
+        _size_rob_ptr                 = log2(_nb_packet          );
+        _size_general_register        = log2(_nb_general_register);
+        _size_special_register        = log2(_nb_special_register);
+        _size_general_data            = size_general_data  ;
+        _size_special_data            = size_special_data  ;
+        _have_port_context_id         = _size_context_id    > 0;
+        _have_port_front_end_id       = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id      = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr            = _size_rob_ptr       > 0;
+        copy();
+      }
     log_printf(FUNC,Write_unit,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Write_unit::Parameters (copy)"
   Parameters::Parameters (Parameters & param):
     _size_write_queue        (param._size_write_queue       ),
     _size_execute_queue      (param._size_execute_queue     ),
     _nb_context              (param._nb_context             ),
     _nb_front_end            (param._nb_front_end           ),
     _nb_ooo_engine           (param._nb_ooo_engine          ),
     _nb_packet               (param._nb_packet              ),
     _size_general_data       (param._size_general_data      ),
     _nb_general_register     (param._nb_general_register    ),
     _size_special_data       (param._size_special_data      ),
     _nb_special_register     (param._nb_special_register    ),
     _nb_bypass_write         (param._nb_bypass_write        ),
+// #undef  FUNCTION
+// #define FUNCTION "Write_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_write_queue        (param._size_write_queue       ),
+//     _size_execute_queue      (param._size_execute_queue     ),
+//     _nb_context              (param._nb_context             ),
+//     _nb_front_end            (param._nb_front_end           ),
+//     _nb_ooo_engine           (param._nb_ooo_engine          ),
+//     _nb_packet               (param._nb_packet              ),
+//     _size_general_data       (param._size_general_data      ),
+//     _nb_general_register     (param._nb_general_register    ),
+//     _size_special_data       (param._size_special_data      ),
+//     _nb_special_register     (param._nb_special_register    ),
+//     _nb_bypass_write         (param._nb_bypass_write        ),
     _nb_gpr_write            (param._nb_gpr_write           ),
     _nb_spr_write            (param._nb_spr_write           ),
+//     _nb_gpr_write            (param._nb_gpr_write           ),
+//     _nb_spr_write            (param._nb_spr_write           ),
     _size_context_id         (param._size_context_id        ),
     _size_front_end_id       (param._size_front_end_id      ),
     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
     _size_packet_id          (param._size_packet_id         ),
     _size_general_register   (param._size_general_register  ),
     _size_special_register   (param._size_special_register  ),
+//     _size_context_id         (param._size_context_id        ),
+//     _size_front_end_id       (param._size_front_end_id      ),
+//     _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+//     _size_packet_id          (param._size_packet_id         ),
+//     _size_general_register   (param._size_general_register  ),
+//     _size_special_register   (param._size_special_register  ),
     _have_component_execute_queue (param._have_component_execute_queue),
     _have_port_context_id         (param._have_port_context_id        ),
     _have_port_front_end_id       (param._have_port_front_end_id      ),
     _have_port_ooo_engine_id      (param._have_port_ooo_engine_id     ),
     _have_port_packet_id          (param._have_port_packet_id         )
+  {
     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
+//     _have_component_execute_queue (param._have_component_execute_queue),
+//     _have_port_context_id         (param._have_port_context_id        ),
+//     _have_port_front_end_id       (param._have_port_front_end_id      ),
+//     _have_port_ooo_engine_id      (param._have_port_ooo_engine_id     ),
+//     _have_port_packet_id          (param._have_port_packet_id         )
+//   {
+//     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
     _param_write_queue   = param._param_write_queue  ;
     _param_execute_queue = param._param_execute_queue;
+//     _param_write_queue   = param._param_write_queue  ;
+//     _param_execute_queue = param._param_execute_queue;
     test();
     log_printf(FUNC,Write_unit,FUNCTION,"End");
   };
+//     test();
+//     log_printf(FUNC,Write_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
 #define FUNCTION "Write_unit::~Parameters"
   Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Write_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Write_unit,FUNCTION,"Begin");
+    COPY(_param_write_queue);
+    if (_have_component_execute_queue)
+    COPY(_param_execute_queue);
+    log_printf(FUNC,Write_unit,FUNCTION,"End");
+  };
 }; // end namespace write_unit
 }; // end namespace multi_write_unit
 …
 }; // end namespace multi_execute_loop
 }; // end namespace core
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
+#if DEBUG_Write_unit == true
+    log_printf(INFO,Write_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Write_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Write_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Write_unit,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Write_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_allocation.cpp

-              r82
+              r88
   void Write_unit::allocation (
 #ifdef STATISTICS
                                morpheo::behavioural::Parameters_Statistics * param_statistics
+                               morpheo::behavioural::Parameters_Statistics * param_statistics
 #else
                                void
 #endif
+                               )
+                               void
+#endif
+                               )
+  {
     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
 …
     Entity * entity = _component->set_entity (_name
                                               ,"Write_unit"
 #ifdef POSITION
                                               ,COMBINATORY
 #endif
                                               );
+                                              ,"Write_unit"
+#ifdef POSITION
+                                              ,COMBINATORY
+#endif
+                                              );
     _interfaces = entity->set_interfaces();
 …
       Interface * interface = _interfaces->set_interface(""
 #ifdef POSITION
                                                          ,IN
                                                          ,SOUTH,
                                                          "Generalist interface"
 #endif
                                                          );
+                                                         ,IN
+                                                         ,SOUTH,
+                                                         "Generalist interface"
+#endif
+                                                         );
      in_CLOCK        = interface->set_signal_clk              ("clock" ,1, CLOCK_VHDL_YES);
 …
        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_packet_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_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_packet_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_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1                          );
        ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_general_data );
+       ALLOC_SIGNAL_OUT(out_WRITE_UNIT_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data );
+     }
 …
+     {
        name = _name+"_write_queue";
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        component_write_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Write_queue
          (name.c_str()
+         (name.c_str()
 #ifdef STATISTICS
           ,param_statistics
 #endif
           ,_param->_param_write_queue
           ,_usage);
+          ,param_statistics
+#endif
+          ,_param->_param_write_queue
+          ,_usage);
        _component->set_component (component_write_queue->_component
 #ifdef POSITION
                                   , 50, 50, 10, 10
 #endif
                                   );
+                                  , 50, 50, 10, 10
+#endif
+                                  );
+     }
 …
+     {
        name = _name+"_execute_queue";
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        component_execute_queue  = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::execute_queue::Execute_queue
          (name.c_str()
+         (name.c_str()
 #ifdef STATISTICS
           ,param_statistics
 #endif
           ,_param->_param_execute_queue
           ,_usage);
+          ,param_statistics
+#endif
+          ,_param->_param_execute_queue
+          ,_usage);
        _component->set_component (component_execute_queue->_component
 #ifdef POSITION
                                   , 50, 50, 10, 10
 #endif
                                   );
+                                  , 50, 50, 10, 10
+#endif
+                                  );
+     }
 …
+     {
        name = _name+"_write_queue";
        std::cout << "Instance : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),name.c_str());
 #ifdef POSITION
        _component->interface_map (name ,"",
                                   _name,"");
+                                  _name,"");
 #endif
 …
 #ifdef POSITION
        _component->interface_map (name ,"write_queue_in",
                                   _name,"write_unit_in");
+                                  _name,"write_unit_in");
 #endif
 …
        if (_param->_have_port_ooo_engine_id)
        _component->port_map(name, "in_WRITE_QUEUE_IN_OOO_ENGINE_ID", _name, "in_WRITE_UNIT_IN_OOO_ENGINE_ID");
        if (_param->_have_port_packet_id)
+       if (_param->_have_port_rob_ptr)
        _component->port_map(name, "in_WRITE_QUEUE_IN_PACKET_ID"    , _name, "in_WRITE_UNIT_IN_PACKET_ID"    );
      //_component->port_map(name, "in_WRITE_QUEUE_IN_OPERATION"    , _name, "in_WRITE_UNIT_IN_OPERATION"    );
 …
        if (_param->_have_component_execute_queue)
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"write_queue_out",
+                                      _name+"_execute_queue", "execute_queue_in");
+#endif
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_VAL"          , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_VAL"          );
+           _component->port_map(name, "in_WRITE_QUEUE_OUT_ACK"          , _name+"_execute_queue","out_EXECUTE_QUEUE_IN_ACK"          );
+           if (_param->_have_port_context_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_CONTEXT_ID"   );
+           if (_param->_have_port_front_end_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_FRONT_END_ID" );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID");
+           if (_param->_have_port_packet_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_PACKET_ID"    , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_PACKET_ID"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_OPERATION"    , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_OPERATION"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_TYPE"         , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_TYPE"         );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FLAGS"        , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_FLAGS"        );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_EXCEPTION"    , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_EXCEPTION"    );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_NO_SEQUENCE"  );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_ADDRESS"      , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_ADDRESS"      );
+         }
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"write_queue_out",
+                                      _name+"_execute_queue", "execute_queue_in");
+#endif
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_VAL"          , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_VAL"          );
+           _component->port_map(name, "in_WRITE_QUEUE_OUT_ACK"          , _name+"_execute_queue","out_EXECUTE_QUEUE_IN_ACK"          );
+           if (_param->_have_port_context_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_CONTEXT_ID"   );
+           if (_param->_have_port_front_end_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_FRONT_END_ID" );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID");
+           if (_param->_have_port_rob_ptr)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_PACKET_ID"    , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_PACKET_ID"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_OPERATION"    , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_OPERATION"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_TYPE"         , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_TYPE"         );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FLAGS"        , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_FLAGS"        );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_EXCEPTION"    , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_EXCEPTION"    );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_NO_SEQUENCE"  );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_ADDRESS"      , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_ADDRESS"      );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_DATA"         , _name+"_execute_queue", "in_EXECUTE_QUEUE_IN_DATA"         );
+         }
        else
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"write_queue_out",
+                                      _name,"write_unit_out");
+#endif
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_VAL"          , _name,"out_WRITE_UNIT_OUT_VAL"          );
+           _component->port_map(name, "in_WRITE_QUEUE_OUT_ACK"          , _name, "in_WRITE_UNIT_OUT_ACK"          );
+           if (_param->_have_port_context_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , _name,"out_WRITE_UNIT_OUT_CONTEXT_ID"   );
+           if (_param->_have_port_front_end_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , _name,"out_WRITE_UNIT_OUT_FRONT_END_ID" );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", _name,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID");
+           if (_param->_have_port_packet_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_PACKET_ID"    , _name,"out_WRITE_UNIT_OUT_PACKET_ID"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_OPERATION"    , _name,"out_WRITE_UNIT_OUT_OPERATION"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_TYPE"         , _name,"out_WRITE_UNIT_OUT_TYPE"         );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FLAGS"        , _name,"out_WRITE_UNIT_OUT_FLAGS"        );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_EXCEPTION"    , _name,"out_WRITE_UNIT_OUT_EXCEPTION"    );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , _name,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_ADDRESS"      , _name,"out_WRITE_UNIT_OUT_ADDRESS"      );
+         }
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"write_queue_out",
+                                      _name,"write_unit_out");
+#endif
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_VAL"          , _name,"out_WRITE_UNIT_OUT_VAL"          );
+           _component->port_map(name, "in_WRITE_QUEUE_OUT_ACK"          , _name, "in_WRITE_UNIT_OUT_ACK"          );
+           if (_param->_have_port_context_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_CONTEXT_ID"   , _name,"out_WRITE_UNIT_OUT_CONTEXT_ID"   );
+           if (_param->_have_port_front_end_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FRONT_END_ID" , _name,"out_WRITE_UNIT_OUT_FRONT_END_ID" );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_OOO_ENGINE_ID", _name,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID");
+           if (_param->_have_port_rob_ptr)
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_PACKET_ID"    , _name,"out_WRITE_UNIT_OUT_PACKET_ID"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_OPERATION"    , _name,"out_WRITE_UNIT_OUT_OPERATION"    );
+         //_component->port_map(name,"out_WRITE_QUEUE_OUT_TYPE"         , _name,"out_WRITE_UNIT_OUT_TYPE"         );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_FLAGS"        , _name,"out_WRITE_UNIT_OUT_FLAGS"        );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_EXCEPTION"    , _name,"out_WRITE_UNIT_OUT_EXCEPTION"    );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_NO_SEQUENCE"  , _name,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_ADDRESS"      , _name,"out_WRITE_UNIT_OUT_ADDRESS"      );
+           _component->port_map(name,"out_WRITE_QUEUE_OUT_DATA"         , _name,"out_WRITE_UNIT_OUT_DATA"         );
+         }
        for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
+         {
 #ifdef POSITION
            _component->interface_map (name ,"gpr_write_"+toString(i),
                                       _name,"gpr_write_"+toString(i));
 #endif
            _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_VAL"          ,_name,"out_GPR_WRITE_"+toString(i)+"_VAL"          );
            _component->port_map(name, "in_GPR_WRITE_"+toString(i)+"_ACK"          ,_name, "in_GPR_WRITE_"+toString(i)+"_ACK"          );
            if (_param->_have_port_ooo_engine_id)
            _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",_name,"out_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
            _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_NUM_REG"      ,_name,"out_GPR_WRITE_"+toString(i)+"_NUM_REG"      );
            _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_DATA"         ,_name,"out_GPR_WRITE_"+toString(i)+"_DATA"         );
+         }
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"gpr_write_"+toString(i),
+                                      _name,"gpr_write_"+toString(i));
+#endif
+           _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_VAL"          ,_name,"out_GPR_WRITE_"+toString(i)+"_VAL"          );
+           _component->port_map(name, "in_GPR_WRITE_"+toString(i)+"_ACK"          ,_name, "in_GPR_WRITE_"+toString(i)+"_ACK"          );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",_name,"out_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
+           _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_NUM_REG"      ,_name,"out_GPR_WRITE_"+toString(i)+"_NUM_REG"      );
+           _component->port_map(name,"out_GPR_WRITE_"+toString(i)+"_DATA"         ,_name,"out_GPR_WRITE_"+toString(i)+"_DATA"         );
+         }
        for (uint32_t i=0; i<_param->_nb_spr_write; i++)
+         {
 #ifdef POSITION
            _component->interface_map (name ,"spr_write_"+toString(i),
                                       _name,"spr_write_"+toString(i));
 #endif
            _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_VAL"          ,_name,"out_SPR_WRITE_"+toString(i)+"_VAL"          );
            _component->port_map(name, "in_SPR_WRITE_"+toString(i)+"_ACK"          ,_name, "in_SPR_WRITE_"+toString(i)+"_ACK"          );
            if (_param->_have_port_ooo_engine_id)
            _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",_name,"out_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
            _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_NUM_REG"      ,_name,"out_SPR_WRITE_"+toString(i)+"_NUM_REG"      );
            _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_DATA"         ,_name,"out_SPR_WRITE_"+toString(i)+"_DATA"         );
+         }
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"spr_write_"+toString(i),
+                                      _name,"spr_write_"+toString(i));
+#endif
+           _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_VAL"          ,_name,"out_SPR_WRITE_"+toString(i)+"_VAL"          );
+           _component->port_map(name, "in_SPR_WRITE_"+toString(i)+"_ACK"          ,_name, "in_SPR_WRITE_"+toString(i)+"_ACK"          );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",_name,"out_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
+           _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_NUM_REG"      ,_name,"out_SPR_WRITE_"+toString(i)+"_NUM_REG"      );
+           _component->port_map(name,"out_SPR_WRITE_"+toString(i)+"_DATA"         ,_name,"out_SPR_WRITE_"+toString(i)+"_DATA"         );
+         }
        for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
+         {
 #ifdef POSITION
            _component->interface_map (name ,"bypass_write_"+toString(i),
                                       _name,"bypass_write_"+toString(i));
 #endif
            if (_param->_have_port_ooo_engine_id)
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_OOO_ENGINE_ID",_name,"out_BYPASS_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_VAL"      ,_name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_VAL"      );
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_NUM_REG"  ,_name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_NUM_REG"  );
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_DATA"     ,_name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_DATA"     );
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_VAL"      ,_name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_VAL"      );
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_NUM_REG"  ,_name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_NUM_REG"  );
            _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_DATA"     ,_name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_DATA"     );
+         }
+         {
+#ifdef POSITION
+           _component->interface_map (name ,"bypass_write_"+toString(i),
+                                      _name,"bypass_write_"+toString(i));
+#endif
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_OOO_ENGINE_ID",_name,"out_BYPASS_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_VAL"      ,_name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_VAL"      );
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_NUM_REG"  ,_name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_NUM_REG"  );
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_DATA"     ,_name,"out_BYPASS_WRITE_"+toString(i)+"_GPR_DATA"     );
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_VAL"      ,_name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_VAL"      );
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_NUM_REG"  ,_name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_NUM_REG"  );
+           _component->port_map(name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_DATA"     ,_name,"out_BYPASS_WRITE_"+toString(i)+"_SPR_DATA"     );
+         }
+     }
      if (_param->_have_component_execute_queue)
+       {
          name = _name+"_execute_queue";
          std::cout << "Instance : " << name << std::endl;
 #ifdef POSITION
          _component->interface_map (name ,"",
                                     _name,"");
 #endif
          _component->port_map(name,"in_CLOCK" , _name, "in_CLOCK");
          _component->port_map(name,"in_NRESET", _name, "in_NRESET");
 #ifdef POSITION
          _component->interface_map (name ,"execute_queue_in",
                                     _name+"_write_queue","write_queue_in");
+         name = _name+"_execute_queue";
+         log_printf(INFO,Core,FUNCTION,_("Instance : %s"),name.c_str());
+#ifdef POSITION
+         _component->interface_map (name ,"",
+                                    _name,"");
+#endif
+         _component->port_map(name,"in_CLOCK" , _name, "in_CLOCK");
+         _component->port_map(name,"in_NRESET", _name, "in_NRESET");
+#ifdef POSITION
+         _component->interface_map (name ,"execute_queue_in",
+                                    _name+"_write_queue","write_queue_in");
 #endif
 …
          if (_param->_have_port_ooo_engine_id)
          _component->port_map(name, "in_EXECUTE_QUEUE_IN_OOO_ENGINE_ID", _name+"_write_queue","out_WRITE_QUEUE_OUT_OOO_ENGINE_ID");
          if (_param->_have_port_packet_id)
+         if (_param->_have_port_rob_ptr)
          _component->port_map(name, "in_EXECUTE_QUEUE_IN_PACKET_ID"    , _name+"_write_queue","out_WRITE_QUEUE_OUT_PACKET_ID"    );
        //_component->port_map(name, "in_EXECUTE_QUEUE_IN_OPERATION"    , _name+"_write_queue","out_WRITE_QUEUE_OUT_OPERATION"    );
 …
          _component->port_map(name, "in_EXECUTE_QUEUE_IN_NO_SEQUENCE"  , _name+"_write_queue","out_WRITE_QUEUE_OUT_NO_SEQUENCE"  );
          _component->port_map(name, "in_EXECUTE_QUEUE_IN_ADDRESS"      , _name+"_write_queue","out_WRITE_QUEUE_OUT_ADDRESS"      );
+#ifdef POSITION
+           _component->interface_map (name ,"execute_queue_out",
+                                      _name,"write_unit_out");
+#endif
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_VAL"          , _name,"out_WRITE_UNIT_OUT_VAL"          );
+           _component->port_map(name, "in_EXECUTE_QUEUE_OUT_ACK"          , _name, "in_WRITE_UNIT_OUT_ACK"          );
+           if (_param->_have_port_context_id)
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_CONTEXT_ID"   , _name,"out_WRITE_UNIT_OUT_CONTEXT_ID"   );
+           if (_param->_have_port_front_end_id)
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_FRONT_END_ID" , _name,"out_WRITE_UNIT_OUT_FRONT_END_ID" );
+           if (_param->_have_port_ooo_engine_id)
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID", _name,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID");
+           if (_param->_have_port_packet_id)
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_PACKET_ID"    , _name,"out_WRITE_UNIT_OUT_PACKET_ID"    );
+         //_component->port_map(name,"out_EXECUTE_QUEUE_OUT_OPERATION"    , _name,"out_WRITE_UNIT_OUT_OPERATION"    );
+         //_component->port_map(name,"out_EXECUTE_QUEUE_OUT_TYPE"         , _name,"out_WRITE_UNIT_OUT_TYPE"         );
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_FLAGS"        , _name,"out_WRITE_UNIT_OUT_FLAGS"        );
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_EXCEPTION"    , _name,"out_WRITE_UNIT_OUT_EXCEPTION"    );
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , _name,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  );
+           _component->port_map(name,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , _name,"out_WRITE_UNIT_OUT_ADDRESS"      );
+         _component->port_map(name, "in_EXECUTE_QUEUE_IN_DATA"         , _name+"_write_queue","out_WRITE_QUEUE_OUT_DATA"         );
+#ifdef POSITION
+         _component->interface_map (name ,"execute_queue_out",
+                                    _name,"write_unit_out");
+#endif
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_VAL"          , _name,"out_WRITE_UNIT_OUT_VAL"          );
+         _component->port_map(name, "in_EXECUTE_QUEUE_OUT_ACK"          , _name, "in_WRITE_UNIT_OUT_ACK"          );
+         if (_param->_have_port_context_id)
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_CONTEXT_ID"   , _name,"out_WRITE_UNIT_OUT_CONTEXT_ID"   );
+         if (_param->_have_port_front_end_id)
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_FRONT_END_ID" , _name,"out_WRITE_UNIT_OUT_FRONT_END_ID" );
+         if (_param->_have_port_ooo_engine_id)
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_OOO_ENGINE_ID", _name,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID");
+         if (_param->_have_port_rob_ptr)
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_PACKET_ID"    , _name,"out_WRITE_UNIT_OUT_PACKET_ID"    );
+       //_component->port_map(name,"out_EXECUTE_QUEUE_OUT_OPERATION"    , _name,"out_WRITE_UNIT_OUT_OPERATION"    );
+       //_component->port_map(name,"out_EXECUTE_QUEUE_OUT_TYPE"         , _name,"out_WRITE_UNIT_OUT_TYPE"         );
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_FLAGS"        , _name,"out_WRITE_UNIT_OUT_FLAGS"        );
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_EXCEPTION"    , _name,"out_WRITE_UNIT_OUT_EXCEPTION"    );
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_NO_SEQUENCE"  , _name,"out_WRITE_UNIT_OUT_NO_SEQUENCE"  );
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_ADDRESS"      , _name,"out_WRITE_UNIT_OUT_ADDRESS"      );
+         _component->port_map(name,"out_EXECUTE_QUEUE_OUT_DATA"         , _name,"out_WRITE_UNIT_OUT_DATA"         );
+       }
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Write_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete      in_WRITE_UNIT_IN_OOO_ENGINE_ID;
         if (_param->_have_port_packet_id)
+        if (_param->_have_port_rob_ptr)
         delete      in_WRITE_UNIT_IN_PACKET_ID    ;
 //      delete      in_WRITE_UNIT_IN_OPERATION    ;
 …
         if (_param->_have_port_ooo_engine_id)
         delete     out_WRITE_UNIT_OUT_OOO_ENGINE_ID;
         if (_param->_have_port_packet_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_NO_SEQUENCE  ;
         delete     out_WRITE_UNIT_OUT_ADDRESS      ;
+        delete     out_WRITE_UNIT_OUT_DATA         ;
         // -----[ Interface "gpr_write" ]-------------------------------------

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/src/Write_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Execution_unit_to_Write_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_min.cfg

-              r81
+              r88
 Execution_unit_to_Write_unit
        2       *2      # nb_execute_unit
+       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
        1       *2      # nb_write_unit
        1       *2      # nb_context
 …
       16      *2      # nb_special_register
        1       +1      # priority
        1       +1      # table_routing        [0][0]
        1       +1      # table_routing        [1][0]
+       1       +1      # table_routing        [0][0][0]
+       1       +1      # table_routing        [1][0][0]
        1       +1      # table_execute_thread [0][0]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-mono_thread.cfg

-              r81
+              r88
 Execution_unit_to_Write_unit
        4       *2      # nb_execute_unit
+       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
        3       *2      # nb_write_unit
        1       *2      # nb_context
 …
       16      *2      # nb_special_register
        1       +1      # priority
        1       +1      # table_routing [0][0]
        0       +1      # table_routing [0][1]
        0       +1      # table_routing [0][2]
        0       +1      # table_routing [1][0]
        1       +1      # table_routing [1][1]
        1       +1      # table_routing [1][2]
        0       +1      # table_routing [2][0]
        0       +1      # table_routing [2][1]
        1       +1      # table_routing [2][2]
        1       +1      # table_routing [3][0]
        1       +1      # table_routing [3][1]
        1       +1      # table_routing [3][2]
+       1       +1      # table_routing [0][0][0]
+       0       +1      # table_routing [0][1][0]
+       0       +1      # table_routing [0][2][0]
+       0       +1      # table_routing [1][0][0]
+       1       +1      # table_routing [1][1][0]
+       1       +1      # table_routing [1][2][0]
+       0       +1      # table_routing [2][0][0]
+       0       +1      # table_routing [2][1][0]
+       1       +1      # table_routing [2][2][0]
+       1       +1      # table_routing [3][0][0]
+       1       +1      # table_routing [3][1][0]
+       1       +1      # table_routing [3][2][0]
        1       +1      # table_thread  [0][0]
        1       +1      # table_thread  [1][0]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/config_multi_execute-multi_thread.cfg

-              r81
+              r88
 Execution_unit_to_Write_unit
        4       *2      # nb_execute_unit
+       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
        3       *2      # nb_write_unit
        2       *2      # nb_context
 …
       16      *2      # nb_special_register
        1       +1      # priority
        1       +1      # table_routing [0][0]
        0       +1      # table_routing [0][1]
        0       +1      # table_routing [0][2]
        0       +1      # table_routing [1][0]
        1       +1      # table_routing [1][1]
        1       +1      # table_routing [1][2]
        0       +1      # table_routing [2][0]
        0       +1      # table_routing [2][1]
        1       +1      # table_routing [2][2]
        1       +1      # table_routing [3][0]
        1       +1      # table_routing [3][1]
        1       +1      # table_routing [3][2]
+       1       +1      # table_routing [0][0][0]
+       0       +1      # table_routing [0][1][0]
+       0       +1      # table_routing [0][2][0]
+       0       +1      # table_routing [1][0][0]
+       1       +1      # table_routing [1][1][0]
+       1       +1      # table_routing [1][2][0]
+       0       +1      # table_routing [2][0][0]
+       0       +1      # table_routing [2][1][0]
+       1       +1      # table_routing [2][2][0]
+       1       +1      # table_routing [3][0][0]
+       1       +1      # table_routing [3][1][0]
+       1       +1      # table_routing [3][2][0]
        1       +1      # table_thread  [0][0]
        0       +1      # table_thread  [0][1]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h

-              r81
+              r88
 #include <sys/time.h>
+#define NB_ITERATION  1
+#define CYCLE_MAX     (128*NB_ITERATION)
 #include "Common/include/Time.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h"
+#include "Common/include/Test.h"
 using namespace std;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/main.cpp

-              r81
+              r88
   err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
   err (_("list_params is :\n"));
+  err (_("  * nb_execute_unit                                (uint32_t)\n"));
+  err (_("  * nb_write_unit                                  (uint32_t)\n"));
+  err (_("  * nb_context                                     (uint32_t)\n"));
+  err (_("  * nb_front_end                                   (uint32_t)\n"));
+  err (_("  * nb_ooo_engine                                  (uint32_t)\n"));
+  err (_("  * nb_packet                                      (uint32_t)\n"));
+  err (_("  * size_general_data                              (uint32_t)\n"));
+  err (_("  * size_special_data                              (uint32_t)\n"));
+  err (_("  * nb_general_register                            (uint32_t)\n"));
+  err (_("  * nb_special_register                            (uint32_t)\n"));
+  err (_("  * priority                                       (uint32_t)\n"));
+  err (_("  * table_routing [nb_execute_unit][nb_write_unit] (bool    )\n"));
+  err (_("  * table_thread  [nb_write_unit][nb_thread]       (bool    )\n"));
+  err (_("  * nb_execute_unit                                                      (uint32_t)\n"));
+  err (_("  * nb_execute_unit_port [nb_execute_unit]                               (uint32_t)\n"));
+  err (_("  * nb_write_unit                                                        (uint32_t)\n"));
+  err (_("  * nb_context                                                           (uint32_t)\n"));
+  err (_("  * nb_front_end                                                         (uint32_t)\n"));
+  err (_("  * nb_ooo_engine                                                        (uint32_t)\n"));
+  err (_("  * nb_packet                                                            (uint32_t)\n"));
+  err (_("  * size_general_data                                                    (uint32_t)\n"));
+  err (_("  * size_special_data                                                    (uint32_t)\n"));
+  err (_("  * nb_general_register                                                  (uint32_t)\n"));
+  err (_("  * nb_special_register                                                  (uint32_t)\n"));
+  err (_("  * priority                                                             (uint32_t)\n"));
+  err (_("  * table_routing [nb_execute_unit][nb_execute_unit_port][nb_write_unit] (bool    )\n"));
+  err (_("  * table_thread  [nb_write_unit][nb_thread]                             (bool    )\n"));
   exit (1);
 …
   const string   name      =      argv[x++];
+  uint32_t    _nb_execute_unit      = atoi(argv[x++]);
+  uint32_t    _nb_write_unit        = atoi(argv[x++]);
+  uint32_t    _nb_context           = atoi(argv[x++]);
+  uint32_t    _nb_front_end         = atoi(argv[x++]);
+  uint32_t    _nb_ooo_engine        = atoi(argv[x++]);
+  uint32_t    _nb_packet            = atoi(argv[x++]);
+  uint32_t    _size_general_data    = atoi(argv[x++]);
+  uint32_t    _size_special_data    = atoi(argv[x++]);
+  uint32_t    _nb_general_register  = atoi(argv[x++]);
+  uint32_t    _nb_special_register  = atoi(argv[x++]);
+  uint32_t    _nb_execute_unit      = fromString<uint32_t>(argv[x++]);
+  if (static_cast<uint32_t>(argc) <= 2+NB_PARAMS+_nb_execute_unit)
+    usage (argc, argv);
+  uint32_t    _sum_execute_unit_port = 0;
+  uint32_t *  _nb_execute_unit_port = new uint32_t [_nb_execute_unit];
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    {
+      _nb_execute_unit_port [i] = fromString<uint32_t>(argv[x++]);
+      _sum_execute_unit_port += _nb_execute_unit_port [i];
+    }
+  uint32_t    _nb_write_unit        = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_context           = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_front_end         = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_ooo_engine        = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_packet            = fromString<uint32_t>(argv[x++]);
+  uint32_t    _size_general_data    = fromString<uint32_t>(argv[x++]);
+  uint32_t    _size_special_data    = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_general_register  = fromString<uint32_t>(argv[x++]);
+  uint32_t    _nb_special_register  = fromString<uint32_t>(argv[x++]);
   Tpriority_t _priority             = fromString<Tpriority_t>(argv[x++]);
   uint32_t    _nb_thread            = get_nb_thread(_nb_context, _nb_front_end, _nb_ooo_engine);
   if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_write_unit*_nb_execute_unit)+(_nb_write_unit*_nb_thread))
+  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+_nb_execute_unit+(_nb_write_unit*_sum_execute_unit_port)+(_nb_write_unit*_nb_thread))
     usage (argc, argv);
   bool ** _table_routing;
   bool ** _table_thread ;
+  bool *** _table_routing;
+  bool  ** _table_thread ;
   _table_routing = new bool * [_nb_execute_unit];
+  _table_routing = new bool ** [_nb_execute_unit];
   for (uint32_t i=0; i<_nb_execute_unit; i++)
+    {
+      _table_routing [i] = new bool [_nb_write_unit];
+      for (uint32_t j=0; j<_nb_write_unit; j++)
+        _table_routing [i][j] = atoi(argv[x++]);
+      _table_routing [i] = new bool * [_nb_execute_unit_port [i]];
+      for (uint32_t j=0; j<_nb_execute_unit_port [i]; j++)
+        {
+          _table_routing [i][j] = new bool [_nb_write_unit];
+          for (uint32_t k=0; k<_nb_write_unit; k++)
+            _table_routing [i][j][k] = fromString<bool>(argv[x++]);
+        }
+    }
 …
       for (uint32_t j=0; j<_nb_thread; j++)
         _table_thread [i][j] = atoi(argv[x++]);
+        _table_thread [i][j] = fromString<bool>(argv[x++]);
+    }
+  int _return = EXIT_SUCCESS;
   try
+    {
       morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
         (_nb_execute_unit      ,
+         _nb_execute_unit_port ,
          _nb_write_unit        ,
          _nb_context           ,
 …
          _priority             ,
          _table_routing        ,
+         _table_thread
+         _table_thread         ,
+         true //is_toplevel
          );
       msg(_("%s"),param->print(1).c_str());
+      msg(_("%s"),param->print(0).c_str());
       test (name,param);
 …
   catch (morpheo::ErrorMorpheo & error)
+    {
       msg (_("<%s> : %s.\n"),name.c_str(), error.what ());
       exit (EXIT_FAILURE);
+      msg (_("<%s> :\n%s"),name.c_str(), error.what ());
+      _return = EXIT_FAILURE;
+    }
+  catch (...)
+  try
+    {
+      err (_("<%s> : This test must generate a error.\n"),name.c_str());
+      exit (EXIT_FAILURE);
+      if (_return == EXIT_SUCCESS)
+        TEST_OK("Execution_unit_to_Write_unit : no error");
+      else
+        TEST_KO("Execution_unit_to_Write_unit : a lot of error");
+    }
+  catch (morpheo::ErrorMorpheo & error)
+    {
+//       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
+      _return = EXIT_FAILURE;
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/src/test.cpp

-              r82
+              r88
  */
-#define NB_ITERATION  1
-#define CYCLE_MAX     (128*NB_ITERATION)
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/SelfTest/include/test.h"
-#include "Common/include/Test.h"
 #include "Common/include/BitManipulation.h"
 #include "Behavioural/include/Allocation.h"
 …
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Execution_unit_to_Write_unit * _Execution_unit_to_Write_unit = new Execution_unit_to_Write_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ," in_EXECUTE_UNIT_OUT_VAL          ",Tcontrol_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,"out_EXECUTE_UNIT_OUT_ACK          ",Tcontrol_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ," in_EXECUTE_UNIT_OUT_CONTEXT_ID   ",Tcontext_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ," in_EXECUTE_UNIT_OUT_FRONT_END_ID ",Tcontext_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID," in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID",Tcontext_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit);
+//ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ," in_EXECUTE_UNIT_OUT_DATA_RD      ",Tgeneral_data_t   ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ," in_EXECUTE_UNIT_OUT_WRITE_RE     ",Tcontrol_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ," in_EXECUTE_UNIT_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ," in_EXECUTE_UNIT_OUT_DATA_RE      ",Tspecial_data_t   ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ," in_EXECUTE_UNIT_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ," in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ",Tcontrol_t        ,_param->_nb_execute_unit);
+  ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ," in_EXECUTE_UNIT_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_execute_unit);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ," in_EXECUTE_UNIT_OUT_VAL          ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,"out_EXECUTE_UNIT_OUT_ACK          ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ," in_EXECUTE_UNIT_OUT_CONTEXT_ID   ",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ," in_EXECUTE_UNIT_OUT_FRONT_END_ID ",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID," in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID",Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ," in_EXECUTE_UNIT_OUT_PACKET_ID    ",Tpacket_t         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+//ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ," in_EXECUTE_UNIT_OUT_OPERATION    ",Toperation_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ," in_EXECUTE_UNIT_OUT_TYPE         ",Ttype_t           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ," in_EXECUTE_UNIT_OUT_WRITE_RD     ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ," in_EXECUTE_UNIT_OUT_NUM_REG_RD   ",Tgeneral_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ," in_EXECUTE_UNIT_OUT_DATA_RD      ",Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ," in_EXECUTE_UNIT_OUT_WRITE_RE     ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ," in_EXECUTE_UNIT_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ," in_EXECUTE_UNIT_OUT_DATA_RE      ",Tspecial_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ," in_EXECUTE_UNIT_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ," in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ",Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ," in_EXECUTE_UNIT_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   ALLOC1_SC_SIGNAL(out_WRITE_UNIT_IN_VAL             ,"out_WRITE_UNIT_IN_VAL             ",Tcontrol_t        ,_param->_nb_write_unit  );
   ALLOC1_SC_SIGNAL( in_WRITE_UNIT_IN_ACK             ," in_WRITE_UNIT_IN_ACK             ",Tcontrol_t        ,_param->_nb_write_unit  );
 …
   (*(_Execution_unit_to_Write_unit->in_NRESET))       (*(in_NRESET));
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit,out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_front_end_id)
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit);
   if (_param->_have_port_packet_id)
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit);
 //INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  if (_param->_have_port_rob_ptr  )
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+//INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execution_unit_to_Write_unit, in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_VAL             ,_param->_nb_write_unit  );
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OOO_ENGINE_ID   ,_param->_nb_write_unit  );
   if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr  )
   INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
 //INSTANCE1_SC_SIGNAL(_Execution_unit_to_Write_unit,out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
 …
   const  int32_t percent_transaction_out = 75;
   set<Tcontext_t> execute_unit_thread [_param->_nb_execute_unit];
+  set<Tcontext_t> execute_unit_thread [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
   for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+    for (uint32_t j=0; j<_param->_nb_write_unit; j++)
+      if (_param->_table_routing[i][j])
+        for (uint32_t k=0; k<_param->_nb_thread; k++)
+          if (_param->_table_thread[j][k])
+            {
+              execute_unit_thread [i].insert(k);
+            }
+    for (uint32_t ii=0; ii<_param->_nb_execute_unit_port[i]; ii++)
+      for (uint32_t j=0; j<_param->_nb_write_unit; j++)
+        if (_param->_table_routing[i][ii][j])
+          for (uint32_t k=0; k<_param->_nb_thread; k++)
+            if (_param->_table_thread[j][k])
+              {
+                execute_unit_thread [i][ii].insert(k);
+              }
   SC_START(0);
   LABEL("Initialisation");
 …
       LABEL("Iteration %d",iteration);
       list<entry_t> request [_param->_nb_execute_unit];
+      list<entry_t> request [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
       uint32_t nb_request_in;
       for (nb_request_in=0; nb_request_in < _param->_nb_packet; )
         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          {
+            if (nb_request_in >= _param->_nb_packet)
+              break;
+            Tcontext_t context_id   ;
+            Tcontext_t front_end_id ;
+            Tcontext_t ooo_engine_id;
+            Tcontext_t num_thread   ;
+            // Find compatible thread
+            do
+              {
+                context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
+                front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
+                ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
+                num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
+                                                front_end_id , _param->_size_front_end_id ,
+                                                ooo_engine_id, _param->_size_ooo_engine_id);
+              }
+            while (execute_unit_thread[i].find(num_thread) == execute_unit_thread[i].end());
+            request[i].push_back(entry_t (context_id   ,
+                                          front_end_id ,
+                                          ooo_engine_id,
+                                          nb_request_in,
+                                          //range<Toperation_t      > (rand(), _param->_size_operation       ),
+                                          range<Ttype_t           > (rand(), _param->_size_type            ),
+                                          range<Tcontrol_t        > (rand(), 2                             ),
+                                          range<Tgeneral_address_t> (rand(), _param->_size_general_register),
+                                          range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                          range<Tcontrol_t        > (rand(), 2                             ),
+                                          range<Tspecial_address_t> (rand(), _param->_size_special_register),
+                                          range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
+                                          range<Texception_t      > (rand(), _param->_size_exception       ),
+                                          range<Tcontrol_t        > (rand(), 2                             ),
+                                          range<Tgeneral_data_t   > (rand(), _param->_size_general_data    )
+                                          ));
+            nb_request_in++;
+          }
+          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+            {
+              if (nb_request_in >= _param->_nb_packet)
+                break;
+              Tcontext_t context_id   ;
+              Tcontext_t front_end_id ;
+              Tcontext_t ooo_engine_id;
+              Tcontext_t num_thread   ;
+              // Find compatible thread
+              do
+                {
+                  context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
+                  front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
+                  ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
+                  num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
+                                                  front_end_id , _param->_size_front_end_id ,
+                                                  ooo_engine_id, _param->_size_ooo_engine_id);
+                }
+              while (execute_unit_thread[i][j].find(num_thread) == execute_unit_thread[i][j].end());
+              request[i][j].push_back(entry_t (context_id   ,
+                                               front_end_id ,
+                                               ooo_engine_id,
+                                               nb_request_in,
+                                               //range<Toperation_t      > (rand(), _param->_size_operation       ),
+                                               range<Ttype_t           > (rand(), _param->_size_type            ),
+                                               range<Tcontrol_t        > (rand(), 2                             ),
+                                               range<Tgeneral_address_t> (rand(), _param->_size_general_register),
+                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                               range<Tcontrol_t        > (rand(), 2                             ),
+                                               range<Tspecial_address_t> (rand(), _param->_size_special_register),
+                                               range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
+                                               range<Texception_t      > (rand(), _param->_size_exception       ),
+                                               range<Tcontrol_t        > (rand(), 2                             ),
+                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    )
+                                               ));
+              nb_request_in++;
+            }
       uint32_t   nb_request_out = 0;
 …
+        {
           for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+            {
+              bool val = not request[i].empty() and ((rand()%100) < percent_transaction_in);
+            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+              {
+                bool val = not request[i][j].empty() and ((rand()%100) < percent_transaction_in);
               in_EXECUTE_UNIT_OUT_VAL [i]->write(val);
               if (val)
+                {
                   in_EXECUTE_UNIT_OUT_CONTEXT_ID           [i] ->write(request[i].front()._context_id           );
                   in_EXECUTE_UNIT_OUT_FRONT_END_ID         [i] ->write(request[i].front()._front_end_id         );
                   in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID        [i] ->write(request[i].front()._ooo_engine_id        );
                   in_EXECUTE_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
 //                in_EXECUTE_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
                   in_EXECUTE_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
                   in_EXECUTE_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
                   in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
                   in_EXECUTE_UNIT_OUT_DATA_RD              [i] ->write(request[i].front()._data_rd              );
                   in_EXECUTE_UNIT_OUT_WRITE_RE             [i] ->write(request[i].front()._write_re             );
                   in_EXECUTE_UNIT_OUT_NUM_REG_RE           [i] ->write(request[i].front()._num_reg_re           );
                   in_EXECUTE_UNIT_OUT_DATA_RE              [i] ->write(request[i].front()._data_re              );
                   in_EXECUTE_UNIT_OUT_EXCEPTION            [i] ->write(request[i].front()._exception            );
                   in_EXECUTE_UNIT_OUT_NO_SEQUENCE          [i] ->write(request[i].front()._no_sequence          );
                   in_EXECUTE_UNIT_OUT_ADDRESS              [i] ->write(request[i].front()._address              );
+                }
+            }
+                in_EXECUTE_UNIT_OUT_VAL [i][j]->write(val);
+                if (val)
+                  {
+                    in_EXECUTE_UNIT_OUT_CONTEXT_ID           [i][j] ->write(request[i][j].front()._context_id           );
+                    in_EXECUTE_UNIT_OUT_FRONT_END_ID         [i][j] ->write(request[i][j].front()._front_end_id         );
+                    in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID        [i][j] ->write(request[i][j].front()._ooo_engine_id        );
+                    in_EXECUTE_UNIT_OUT_PACKET_ID            [i][j] ->write(request[i][j].front()._packet_id            );
+//                  in_EXECUTE_UNIT_OUT_OPERATION            [i][j] ->write(request[i][j].front()._operation            );
+                    in_EXECUTE_UNIT_OUT_TYPE                 [i][j] ->write(request[i][j].front()._type                 );
+                    in_EXECUTE_UNIT_OUT_WRITE_RD             [i][j] ->write(request[i][j].front()._write_rd             );
+                    in_EXECUTE_UNIT_OUT_NUM_REG_RD           [i][j] ->write(request[i][j].front()._num_reg_rd           );
+                    in_EXECUTE_UNIT_OUT_DATA_RD              [i][j] ->write(request[i][j].front()._data_rd              );
+                    in_EXECUTE_UNIT_OUT_WRITE_RE             [i][j] ->write(request[i][j].front()._write_re             );
+                    in_EXECUTE_UNIT_OUT_NUM_REG_RE           [i][j] ->write(request[i][j].front()._num_reg_re           );
+                    in_EXECUTE_UNIT_OUT_DATA_RE              [i][j] ->write(request[i][j].front()._data_re              );
+                    in_EXECUTE_UNIT_OUT_EXCEPTION            [i][j] ->write(request[i][j].front()._exception            );
+                    in_EXECUTE_UNIT_OUT_NO_SEQUENCE          [i][j] ->write(request[i][j].front()._no_sequence          );
+                    in_EXECUTE_UNIT_OUT_ADDRESS              [i][j] ->write(request[i][j].front()._address              );
+                  }
+              }
           for (uint32_t i=0; i<_param->_nb_write_unit; i++)
 …
           for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+            if (in_EXECUTE_UNIT_OUT_VAL [i]->read() and out_EXECUTE_UNIT_OUT_ACK [i]->read())
+              {
+                LABEL("EXECUTE_UNIT_OUT   [%d] - Transaction accepted",i);
+              }
+            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+              if (in_EXECUTE_UNIT_OUT_VAL [i][j]->read() and out_EXECUTE_UNIT_OUT_ACK [i][j]->read())
+                {
+                  LABEL("EXECUTE_UNIT_OUT   [%d][%d] - Transaction accepted",i,j);
+                }
           for (uint32_t i=0; i<_param->_nb_write_unit; i++)
             if (out_WRITE_UNIT_IN_VAL [i]->read() and in_WRITE_UNIT_IN_ACK [i]->read())
 …
                 nb_request_out ++;
+                Tpacket_t packet = (_param->_have_port_packet_id)?out_WRITE_UNIT_IN_PACKET_ID[i]->read():0;
+                LABEL("  * packet           : %d",packet);
+                uint32_t execute_unit;
+                Tpacket_t packet = (_param->_have_port_rob_ptr  )?out_WRITE_UNIT_IN_PACKET_ID[i]->read():0;
+                LABEL("  * packet              : %d",packet);
                 // find execute_unit
+                for (execute_unit=0; execute_unit<_param->_nb_execute_unit; execute_unit++)
+                  if (packet == ((_param->_have_port_packet_id)?request[execute_unit].front()._packet_id:0))
+                    break;
+                LABEL("  * execute_unit source : %d",execute_unit);
+                if (_param->_have_port_packet_id)
+                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_PACKET_ID            [i]->read(), request[execute_unit].front()._packet_id            );
+                uint32_t x = 0;
+                uint32_t y = 0;
+                bool     find = false;
+                for (x=0; x<_param->_nb_execute_unit; x++)
+                  {
+                    for (y=0; y<_param->_nb_execute_unit_port[x]; y++)
+                      if (packet == ((_param->_have_port_rob_ptr  )?request[x][y].front()._packet_id:0))
+                        {
+                          find = true;
+                          break;
+                        }
+                    if (find)
+                      break;
+                  }
+                LABEL("  * execute_unit source : %d",x);
+                LABEL("  * execute_unit port   : %d",y);
+                TEST(bool,x<_param->_nb_execute_unit, true);
+                TEST(bool,y<_param->_nb_execute_unit_port[x],true);
+                if (_param->_have_port_rob_ptr  )
+                TEST(Tpacket_t         ,packet                                            , request[x][y].front()._packet_id            );
                 // Authorised link ? execute_unit -> write_unit
                 TEST(bool, _param->_table_routing[execute_unit][i], true);
+                TEST(bool, _param->_table_routing[x][y][i], true);
                 if (_param->_have_port_context_id)
                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_CONTEXT_ID           [i]->read(), request[execute_unit].front()._context_id           );
+                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_CONTEXT_ID           [i]->read(), request[x][y].front()._context_id           );
                 if (_param->_have_port_front_end_id)
                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_FRONT_END_ID         [i]->read(), request[execute_unit].front()._front_end_id         );
+                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_FRONT_END_ID         [i]->read(), request[x][y].front()._front_end_id         );
                 if (_param->_have_port_ooo_engine_id)
                 TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[execute_unit].front()._ooo_engine_id        );
 //              TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[execute_unit].front()._operation            );
                 TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[execute_unit].front()._type                 );
                 TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[execute_unit].front()._write_rd             );
                 TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[execute_unit].front()._num_reg_rd           );
                 TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_DATA_RD              [i]->read(), request[execute_unit].front()._data_rd              );
                 TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RE             [i]->read(), request[execute_unit].front()._write_re             );
                 TEST(Tspecial_address_t,out_WRITE_UNIT_IN_NUM_REG_RE           [i]->read(), request[execute_unit].front()._num_reg_re           );
                 TEST(Tspecial_data_t   ,out_WRITE_UNIT_IN_DATA_RE              [i]->read(), request[execute_unit].front()._data_re              );
                 TEST(Texception_t      ,out_WRITE_UNIT_IN_EXCEPTION            [i]->read(), request[execute_unit].front()._exception            );
                 TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_NO_SEQUENCE          [i]->read(), request[execute_unit].front()._no_sequence          );
                 TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_ADDRESS              [i]->read(), request[execute_unit].front()._address              );
+                TEST(Tcontext_t        ,out_WRITE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[x][y].front()._ooo_engine_id        );
+//              TEST(Toperation_t      ,out_WRITE_UNIT_IN_OPERATION            [i]->read(), request[x][y].front()._operation            );
+                TEST(Ttype_t           ,out_WRITE_UNIT_IN_TYPE                 [i]->read(), request[x][y].front()._type                 );
+                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RD             [i]->read(), request[x][y].front()._write_rd             );
+                TEST(Tgeneral_address_t,out_WRITE_UNIT_IN_NUM_REG_RD           [i]->read(), request[x][y].front()._num_reg_rd           );
+                TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_DATA_RD              [i]->read(), request[x][y].front()._data_rd              );
+                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_WRITE_RE             [i]->read(), request[x][y].front()._write_re             );
+                TEST(Tspecial_address_t,out_WRITE_UNIT_IN_NUM_REG_RE           [i]->read(), request[x][y].front()._num_reg_re           );
+                TEST(Tspecial_data_t   ,out_WRITE_UNIT_IN_DATA_RE              [i]->read(), request[x][y].front()._data_re              );
+                TEST(Texception_t      ,out_WRITE_UNIT_IN_EXCEPTION            [i]->read(), request[x][y].front()._exception            );
+                TEST(Tcontrol_t        ,out_WRITE_UNIT_IN_NO_SEQUENCE          [i]->read(), request[x][y].front()._no_sequence          );
+                TEST(Tgeneral_data_t   ,out_WRITE_UNIT_IN_ADDRESS              [i]->read(), request[x][y].front()._address              );
                 request[execute_unit].pop_front();
+                request[x][y].pop_front();
+              }
           SC_START(1);
 …
   delete in_NRESET;
   delete []  in_EXECUTE_UNIT_OUT_VAL          ;
   delete [] out_EXECUTE_UNIT_OUT_ACK          ;
   delete []  in_EXECUTE_UNIT_OUT_CONTEXT_ID   ;
   delete []  in_EXECUTE_UNIT_OUT_FRONT_END_ID ;
   delete []  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID;
   delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
 //delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
   delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
   delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
   delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
   delete []  in_EXECUTE_UNIT_OUT_DATA_RD      ;
   delete []  in_EXECUTE_UNIT_OUT_WRITE_RE     ;
   delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RE   ;
   delete []  in_EXECUTE_UNIT_OUT_DATA_RE      ;
   delete []  in_EXECUTE_UNIT_OUT_EXCEPTION    ;
   delete []  in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ;
   delete []  in_EXECUTE_UNIT_OUT_ADDRESS      ;
   delete [] out_WRITE_UNIT_IN_VAL             ;
   delete []  in_WRITE_UNIT_IN_ACK             ;
   delete [] out_WRITE_UNIT_IN_CONTEXT_ID      ;
   delete [] out_WRITE_UNIT_IN_FRONT_END_ID    ;
   delete [] out_WRITE_UNIT_IN_OOO_ENGINE_ID   ;
   delete [] out_WRITE_UNIT_IN_PACKET_ID       ;
 //delete [] out_WRITE_UNIT_IN_OPERATION       ;
   delete [] out_WRITE_UNIT_IN_TYPE            ;
   delete [] out_WRITE_UNIT_IN_WRITE_RD        ;
   delete [] out_WRITE_UNIT_IN_NUM_REG_RD      ;
   delete [] out_WRITE_UNIT_IN_DATA_RD         ;
   delete [] out_WRITE_UNIT_IN_WRITE_RE        ;
   delete [] out_WRITE_UNIT_IN_NUM_REG_RE      ;
   delete [] out_WRITE_UNIT_IN_DATA_RE         ;
   delete [] out_WRITE_UNIT_IN_EXCEPTION       ;
   delete [] out_WRITE_UNIT_IN_NO_SEQUENCE     ;
   delete [] out_WRITE_UNIT_IN_ADDRESS         ;
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+//DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_VAL             ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL( in_WRITE_UNIT_IN_ACK             ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_CONTEXT_ID      ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_FRONT_END_ID    ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_OOO_ENGINE_ID   ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID       ,_param->_nb_write_unit  );
+//DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_OPERATION       ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_TYPE            ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD        ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD      ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_DATA_RD         ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_WRITE_RE        ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RE      ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_DATA_RE         ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_EXCEPTION       ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_NO_SEQUENCE     ,_param->_nb_write_unit  );
+  DELETE1_SC_SIGNAL(out_WRITE_UNIT_IN_ADDRESS         ,_param->_nb_write_unit  );
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h

-              r82
+              r88
     // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_VAL            ;
   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_OUT_ACK            ;
   public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_CONTEXT_ID     ;
   public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_FRONT_END_ID   ;
   public    : SC_IN (Tcontext_t        )   **  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID  ;
   public    : SC_IN (Tpacket_t         )   **  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
 //public    : SC_IN (Toperation_t      )   **  in_EXECUTE_UNIT_OUT_OPERATION      ;
   public    : SC_IN (Ttype_t           )   **  in_EXECUTE_UNIT_OUT_TYPE           ;
   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
   public    : SC_IN (Tgeneral_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
   public    : SC_IN (Tgeneral_data_t   )   **  in_EXECUTE_UNIT_OUT_DATA_RD        ;
   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_WRITE_RE       ;
   public    : SC_IN (Tspecial_address_t)   **  in_EXECUTE_UNIT_OUT_NUM_REG_RE     ;
   public    : SC_IN (Tspecial_data_t   )   **  in_EXECUTE_UNIT_OUT_DATA_RE        ;
   public    : SC_IN (Texception_t      )   **  in_EXECUTE_UNIT_OUT_EXCEPTION      ;
   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_OUT_NO_SEQUENCE    ;
   public    : SC_IN (Tgeneral_data_t   )   **  in_EXECUTE_UNIT_OUT_ADDRESS        ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_VAL            ;
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_OUT_ACK            ;
+  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_CONTEXT_ID     ;
+  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_FRONT_END_ID   ;
+  public    : SC_IN (Tcontext_t        )  ***  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID  ;
+  public    : SC_IN (Tpacket_t         )  ***  in_EXECUTE_UNIT_OUT_PACKET_ID      ;
+//public    : SC_IN (Toperation_t      )  ***  in_EXECUTE_UNIT_OUT_OPERATION      ;
+  public    : SC_IN (Ttype_t           )  ***  in_EXECUTE_UNIT_OUT_TYPE           ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_WRITE_RD       ;
+  public    : SC_IN (Tgeneral_address_t)  ***  in_EXECUTE_UNIT_OUT_NUM_REG_RD     ;
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_EXECUTE_UNIT_OUT_DATA_RD        ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_WRITE_RE       ;
+  public    : SC_IN (Tspecial_address_t)  ***  in_EXECUTE_UNIT_OUT_NUM_REG_RE     ;
+  public    : SC_IN (Tspecial_data_t   )  ***  in_EXECUTE_UNIT_OUT_DATA_RE        ;
+  public    : SC_IN (Texception_t      )  ***  in_EXECUTE_UNIT_OUT_EXCEPTION      ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_OUT_NO_SEQUENCE    ;
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_EXECUTE_UNIT_OUT_ADDRESS        ;
     // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   private   : std::list<uint32_t> ** _destination; // [nb_execute_unit][nb_thread];
+  private   : std::list<uint32_t> *** _destination; //[nb_execute_unit][nb_execute_unit_port][nb_thread];
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
+  public : const uint32_t    _nb_execute_unit              ;
+  public : const uint32_t    _nb_write_unit                ;
+  public : const uint32_t    _nb_context                   ;
+  public : const uint32_t    _nb_front_end                 ;
+  public : const uint32_t    _nb_ooo_engine                ;
+  public : const uint32_t    _nb_packet                    ;
+  public : const uint32_t    _size_general_data            ;
+  public : const uint32_t    _size_special_data            ;
+  public : const uint32_t    _nb_general_register          ;
+  public : const uint32_t    _nb_special_register          ;
+  public : const Tpriority_t _priority                     ;
+  public :       bool     ** _table_routing                ; //array [nb_execute_unit][nb_write_unit]
+  public :       bool     ** _table_thread                 ; //array [nb_write_unit][nb_thread]
+  public : uint32_t    _nb_execute_unit              ;
+  public : uint32_t  * _nb_execute_unit_port         ;//[nb_execute_unit]
+  public : uint32_t    _nb_write_unit                ;
+  public : uint32_t    _nb_context                   ;
+  public : uint32_t    _nb_front_end                 ;
+  public : uint32_t    _nb_ooo_engine                ;
+  public : uint32_t    _nb_packet                    ;
+//public : uint32_t    _size_general_data            ;
+//public : uint32_t    _size_special_data            ;
+  public : uint32_t    _nb_general_register          ;
+  public : uint32_t    _nb_special_register          ;
+  public : Tpriority_t _priority                     ;
+  public : bool    *** _table_routing                ; //[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+  public : bool     ** _table_thread                 ; //[nb_write_unit][nb_thread]
+  public : const uint32_t    _size_context_id              ;
+  public : const uint32_t    _size_front_end_id            ;
+  public : const uint32_t    _size_ooo_engine_id           ;
+  public : const uint32_t    _size_packet_id               ;
+  public : const uint32_t    _size_general_register        ;
+  public : const uint32_t    _size_special_register        ;
+  public : uint32_t    _max_nb_execute_unit_port     ;
+//public : uint32_t    _size_context_id              ;
+//public : uint32_t    _size_front_end_id            ;
+//public : uint32_t    _size_ooo_engine_id           ;
+//public : uint32_t    _size_packet_id               ;
+//public : uint32_t    _size_general_register        ;
+//public : uint32_t    _size_special_register        ;
   public : const bool        _have_port_context_id         ;
   public : const bool        _have_port_front_end_id       ;
   public : const bool        _have_port_ooo_engine_id      ;
   public : const bool        _have_port_packet_id          ;
+//public : bool        _have_port_context_id         ;
+//public : bool        _have_port_front_end_id       ;
+//public : bool        _have_port_ooo_engine_id      ;
+//public : bool        _have_port_packet_id          ;
   public : const uint32_t    _nb_thread                    ;
+  public : uint32_t    _nb_thread                    ;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t    nb_execute_unit              ,
+                        uint32_t  * nb_execute_unit_port         ,
                         uint32_t    nb_write_unit                ,
                         uint32_t    nb_context                   ,
 …
                         uint32_t    nb_special_register          ,
                         Tpriority_t priority                     ,
+                        bool     ** table_routing                ,
+                        bool     ** table_thread                 );
+  public : Parameters  (Parameters & param) ;
+                        bool    *** table_routing                ,
+                        bool     ** table_thread                 ,
+                        bool        is_toplevel=false
+                        );
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters ();
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
+#if DEBUG_Execution_unit_to_Write_unit == true
+    log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Method - transition");
 …
         sensitive << (*(in_CLOCK)).pos();
         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          {
+            if (_param->_have_port_context_id)
+            sensitive << (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]));
+            if (_param->_have_port_front_end_id)
+            sensitive << (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]));
+            if (_param->_have_port_ooo_engine_id)
+            sensitive << (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]));
+            if (_param->_have_port_packet_id)
+            sensitive << (*(in_EXECUTE_UNIT_OUT_PACKET_ID     [i]));
+            sensitive << (*(in_EXECUTE_UNIT_OUT_VAL           [i]))
+                    //<< (*(in_EXECUTE_UNIT_OUT_OPERATION     [i]))
+                    //<< (*(in_EXECUTE_UNIT_OUT_TYPE          [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_WRITE_RD      [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD    [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_DATA_RD       [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_WRITE_RE      [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE    [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_DATA_RE       [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_EXCEPTION     [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE   [i]))
+                      << (*(in_EXECUTE_UNIT_OUT_ADDRESS       [i]));
+          }
+          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+            {
+              if (_param->_have_port_context_id)
+              sensitive << (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]));
+              if (_param->_have_port_front_end_id)
+              sensitive << (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]));
+              if (_param->_have_port_ooo_engine_id)
+              sensitive << (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]));
+              if (_param->_have_port_rob_ptr  )
+              sensitive << (*(in_EXECUTE_UNIT_OUT_PACKET_ID     [i][j]));
+              sensitive << (*(in_EXECUTE_UNIT_OUT_VAL           [i][j]))
+                      //<< (*(in_EXECUTE_UNIT_OUT_OPERATION     [i][j]))
+                      //<< (*(in_EXECUTE_UNIT_OUT_TYPE          [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_WRITE_RD      [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD    [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_DATA_RD       [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_WRITE_RE      [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE    [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_DATA_RE       [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_EXCEPTION     [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE   [i][j]))
+                        << (*(in_EXECUTE_UNIT_OUT_ADDRESS       [i][j]));
+            }
         for (uint32_t i=0; i<_param->_nb_write_unit; i++)
           sensitive << (*(in_WRITE_UNIT_IN_ACK [i]));
 …
         // List dependency information
         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          {
+            (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [i]));
+            if (_param->_have_port_context_id)
+            (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]));
+            if (_param->_have_port_front_end_id)
+            (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]));
+            if (_param->_have_port_ooo_engine_id)
+            (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]));
+            for (uint32_t j=0; j<_param->_nb_write_unit; j++)
+              (*(out_EXECUTE_UNIT_OUT_ACK [i])) (*(in_WRITE_UNIT_IN_ACK [j]));
+          }
+          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+            {
+              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_VAL           [i][j]));
+              if (_param->_have_port_context_id)
+              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]));
+              if (_param->_have_port_front_end_id)
+              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]));
+              if (_param->_have_port_ooo_engine_id)
+              (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]));
+              for (uint32_t x=0; x<_param->_nb_write_unit; x++)
+                (*(out_EXECUTE_UNIT_OUT_ACK [i][j])) (*(in_WRITE_UNIT_IN_ACK [x]));
+            }
         for (uint32_t i=0; i<_param->_nb_write_unit; i++)
+          {
             (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
 …
+              {
             (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
 …
+              {
             (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
 …
+              {
             (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+              }
+            if (_param->_have_port_packet_id)
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
+            if (_param->_have_port_rob_ptr  )
+              {
             (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_PACKET_ID [j]));
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_PACKET_ID [x][y]));
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
 //          (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+//          for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+//          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+//            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
 //            {
 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OPERATION [j]));
 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OPERATION [x][y]));
+//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
 //              if (_param->_have_port_context_id)
 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
 //              if (_param->_have_port_front_end_id)
 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
 //              if (_param->_have_port_ooo_engine_id)
 //              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+//              (*(out_WRITE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 //            }
 //          (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+//          for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+//          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+//            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
 //            {
 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_TYPE [j]));
 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_TYPE [x][y]));
+//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
 //              if (_param->_have_port_context_id)
 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
 //              if (_param->_have_port_front_end_id)
 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
 //              if (_param->_have_port_ooo_engine_id)
 //              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+//              (*(out_WRITE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
 //            }
             (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RD [j]));
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RD [x][y]));
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD [j]));
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RD [x][y]));
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RD [j]));
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RD [x][y]));
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_DATA_RD [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RE [j]));
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_WRITE_RE [x][y]));
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE [j]));
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_NUM_REG_RE [x][y]));
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RE [j]));
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_DATA_RE [x][y]));
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_DATA_RE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_EXCEPTION [j]));
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_EXCEPTION [x][y]));
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_EXCEPTION [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE [j]));
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_NO_SEQUENCE [x][y]));
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_NO_SEQUENCE [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_WRITE_UNIT_IN_ACK [i]));
             for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              {
                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_ADDRESS [j]));
                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [j]));
                 if (_param->_have_port_context_id)
                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [j]));
                 if (_param->_have_port_front_end_id)
                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [j]));
                 if (_param->_have_port_ooo_engine_id)
                 (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              {
+                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_ADDRESS [x][y]));
+                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_VAL           [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_WRITE_UNIT_IN_ADDRESS [i])) (*(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+          }
 # endif
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Execution_unit_to_Write_unit,FUNCTION,"Generate Statistics file");

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

-              r81
+              r88
     // ~~~~~[ Interface "execute_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit);
+       ALLOC2_INTERFACE("execute_unit_out", IN, EAST, "Output of execution_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
        ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL);
        ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
      //ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data    );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data    );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception       );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data    );
+       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_OUT_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_OUT_ACK,ACK, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_CONTEXT_ID   ,"context_id"   ,Tcontext_t        ,_param->_size_context_id      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr         , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+     //_ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RD     ,"write_rd"     ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RD   ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RD      ,"data_rd"      ,Tgeneral_data_t   ,_param->_size_general_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_WRITE_RE     ,"write_re"     ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_DATA_RE      ,"data_re"      ,Tspecial_data_t   ,_param->_size_special_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception       , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t        ,1                             , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_EXECUTE_UNIT_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1]);
+     }
     // ~~~~~[ Interface "write_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
 …
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_FRONT_END_ID ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id    );
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t        ,_param->_size_ooo_engine_id   );
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_packet_id       );
+       ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_PACKET_ID    ,"packet_id"    ,Tpacket_t         ,_param->_size_rob_ptr         );
      //ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation       );
        ALLOC1_SIGNAL_OUT(out_WRITE_UNIT_IN_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type            );
 …
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     _destination = new std::list<uint32_t> * [_param->_nb_execute_unit];
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+     _destination = new std::list<uint32_t> ** [_param->_nb_execute_unit];
      for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+       {
+         _destination [i] = new std::list<uint32_t> [_param->_nb_thread];
+         _destination [i] = new std::list<uint32_t> * [_param->_nb_execute_unit_port[i]];
+         for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+           {
+             _destination [i][j] = new std::list<uint32_t> [_param->_nb_thread];
+           }
+       }
+      }
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

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

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Execution_unit_to_Write_unit.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
         delete     in_NRESET;
+        delete []  in_EXECUTE_UNIT_OUT_VAL;
+        delete [] out_EXECUTE_UNIT_OUT_ACK;
+        if (_param->_have_port_context_id)
+        delete []  in_EXECUTE_UNIT_OUT_CONTEXT_ID   ;
+        if (_param->_have_port_front_end_id)
+        delete []  in_EXECUTE_UNIT_OUT_FRONT_END_ID ;
+        if (_param->_have_port_ooo_engine_id)
+        delete []  in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID;
+        if (_param->_have_port_packet_id)
+        delete []  in_EXECUTE_UNIT_OUT_PACKET_ID    ;
+      //delete []  in_EXECUTE_UNIT_OUT_OPERATION    ;
+        delete []  in_EXECUTE_UNIT_OUT_TYPE         ;
+        delete []  in_EXECUTE_UNIT_OUT_WRITE_RD     ;
+        delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RD   ;
+        delete []  in_EXECUTE_UNIT_OUT_DATA_RD      ;
+        delete []  in_EXECUTE_UNIT_OUT_WRITE_RE     ;
+        delete []  in_EXECUTE_UNIT_OUT_NUM_REG_RE   ;
+        delete []  in_EXECUTE_UNIT_OUT_DATA_RE      ;
+        delete []  in_EXECUTE_UNIT_OUT_EXCEPTION    ;
+        delete []  in_EXECUTE_UNIT_OUT_NO_SEQUENCE  ;
+        delete []  in_EXECUTE_UNIT_OUT_ADDRESS      ;
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_VAL          , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1);
+        DELETE2_SIGNAL(out_EXECUTE_UNIT_OUT_ACK          , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1);
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_CONTEXT_ID   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_context_id      );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_FRONT_END_ID , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_front_end_id    );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID, _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_ooo_engine_id   );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_PACKET_ID    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_rob_ptr         );
+     // DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_OPERATION    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_operation       );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_TYPE         , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_type            );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RD     , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RD   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_register);
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RD      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_data    );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_WRITE_RE     , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NUM_REG_RE   , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_special_register);
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_DATA_RE      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_special_data    );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_EXCEPTION    , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_exception       );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_NO_SEQUENCE  , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],1                             );
+        DELETE2_SIGNAL( in_EXECUTE_UNIT_OUT_ADDRESS      , _param->_nb_execute_unit, _param->_nb_execute_unit_port[it1],_param->_size_general_data    );
+        delete [] out_WRITE_UNIT_IN_VAL;
+        delete []  in_WRITE_UNIT_IN_ACK;
+        if (_param->_have_port_context_id)
+        delete [] out_WRITE_UNIT_IN_CONTEXT_ID   ;
+        if (_param->_have_port_front_end_id)
+        delete [] out_WRITE_UNIT_IN_FRONT_END_ID ;
+        if (_param->_have_port_ooo_engine_id)
+        delete [] out_WRITE_UNIT_IN_OOO_ENGINE_ID;
+        if (_param->_have_port_packet_id)
+        delete [] out_WRITE_UNIT_IN_PACKET_ID    ;
+      //delete [] out_WRITE_UNIT_IN_OPERATION    ;
+        delete [] out_WRITE_UNIT_IN_TYPE         ;
+        delete [] out_WRITE_UNIT_IN_WRITE_RD     ;
+        delete [] out_WRITE_UNIT_IN_NUM_REG_RD   ;
+        delete [] out_WRITE_UNIT_IN_DATA_RD      ;
+        delete [] out_WRITE_UNIT_IN_WRITE_RE     ;
+        delete [] out_WRITE_UNIT_IN_NUM_REG_RE   ;
+        delete [] out_WRITE_UNIT_IN_DATA_RE      ;
+        delete [] out_WRITE_UNIT_IN_EXCEPTION    ;
+        delete [] out_WRITE_UNIT_IN_NO_SEQUENCE  ;
+        delete [] out_WRITE_UNIT_IN_ADDRESS      ;
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_VAL          , _param->_nb_write_unit,1);
+        DELETE1_SIGNAL( in_WRITE_UNIT_IN_ACK          , _param->_nb_write_unit,1);
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_CONTEXT_ID   , _param->_nb_write_unit,_param->_size_context_id      );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_FRONT_END_ID , _param->_nb_write_unit,_param->_size_front_end_id    );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_OOO_ENGINE_ID, _param->_nb_write_unit,_param->_size_ooo_engine_id   );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_PACKET_ID    , _param->_nb_write_unit,_param->_size_rob_ptr         );
+     // DELETE1_SIGNAL(out_WRITE_UNIT_IN_OPERATION    , _param->_nb_write_unit,_param->_size_operation       );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_TYPE         , _param->_nb_write_unit,_param->_size_type            );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_WRITE_RD     , _param->_nb_write_unit,1                             );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RD   , _param->_nb_write_unit,_param->_size_general_register);
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_DATA_RD      , _param->_nb_write_unit,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_WRITE_RE     , _param->_nb_write_unit,1                             );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NUM_REG_RE   , _param->_nb_write_unit,_param->_size_special_register);
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_DATA_RE      , _param->_nb_write_unit,_param->_size_special_data    );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_EXCEPTION    , _param->_nb_write_unit,_param->_size_exception       );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_NO_SEQUENCE  , _param->_nb_write_unit,1                             );
+        DELETE1_SIGNAL(out_WRITE_UNIT_IN_ADDRESS      , _param->_nb_write_unit,_param->_size_general_data    );
+        delete [] _destination;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] _destination;
     delete    _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_genMealy.cpp

-              r81
+              r88
     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+      {
+        bool       ack = false;
+        log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"Test execute_unit[%d]",i);
+        if (PORT_READ(in_EXECUTE_UNIT_OUT_VAL [i]) == true)
+          {
+            log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * have a valid entry.");
+            Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i]):0;
+            Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i]):0;
+            Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i]):0;
+            Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
+                                                      front_end_id , _param->_size_front_end_id ,
+                                                      ooo_engine_id, _param->_size_ooo_engine_id);
+      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+        {
+          bool       ack = false;
+          log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"Test execute_unit[%d][%d]",i,j);
+          if (PORT_READ(in_EXECUTE_UNIT_OUT_VAL [i][j]) == true)
+            {
+              log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * have a valid entry.");
+              Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID    [i][j]):0;
+              Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID  [i][j]):0;
+              Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID [i][j]):0;
+              Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
+                                                        front_end_id , _param->_size_front_end_id ,
+                                                        ooo_engine_id, _param->_size_ooo_engine_id);
 #ifdef DEBUG_TEST
             if (_destination[i][num_thread].empty())
               throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no write_unit to receive a operation from the execute_unit ["+toString(i)+"], thread ["+toString(num_thread)+"].");
+              if (_destination[i][j][num_thread].empty())
+                throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no write_unit to receive a operation from the execute_unit ["+toString(i)+"]["+toString(j)+"], thread ["+toString(num_thread)+"].");
 #endif
             // find a free write_unit
             for (std::list<uint32_t>::iterator it=_destination[i][num_thread].begin();
                  (it != _destination[i][num_thread].end()) and (ack == false);
                  it++)
+              {
                 uint32_t dest = *it;
                 log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"   * Test destination [%d].",dest);
                 if (write_unit_use [dest] == false)
+                  {
                     log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"     * Is ok! Link.");
                     // have find !!!
                     ack                   = true;
                     write_unit_use [dest] = true;
                     if (_param->_have_port_context_id)
                     PORT_WRITE(out_WRITE_UNIT_IN_CONTEXT_ID            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_CONTEXT_ID            [i]));
                     if (_param->_have_port_front_end_id)
                     PORT_WRITE(out_WRITE_UNIT_IN_FRONT_END_ID          [dest], PORT_READ(in_EXECUTE_UNIT_OUT_FRONT_END_ID          [i]));
                     if (_param->_have_port_ooo_engine_id)
                     PORT_WRITE(out_WRITE_UNIT_IN_OOO_ENGINE_ID         [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OOO_ENGINE_ID         [i]));
                     if (_param->_have_port_packet_id)
                     PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i]));
                   //PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_DATA_RD               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RD               [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RE              [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RE            [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_DATA_RE               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RE               [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_EXCEPTION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_EXCEPTION             [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_NO_SEQUENCE           [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NO_SEQUENCE           [i]));
                     PORT_WRITE(out_WRITE_UNIT_IN_ADDRESS               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_ADDRESS               [i]));
+                  }
+              }
+          }
         PORT_WRITE(out_EXECUTE_UNIT_OUT_ACK [i], ack);
+              // find a free write_unit
+              for (std::list<uint32_t>::iterator it=_destination[i][j][num_thread].begin();
+                   (it != _destination[i][j][num_thread].end()) and (ack == false);
+                   it++)
+                {
+                  uint32_t dest = *it;
+                  log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"   * Test destination [%d].",dest);
+                  if (write_unit_use [dest] == false)
+                    {
+                      log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"     * Is ok! Link.");
+                      // have find !!!
+                      ack                   = true;
+                      write_unit_use [dest] = true;
+                      if (_param->_have_port_context_id)
+                      PORT_WRITE(out_WRITE_UNIT_IN_CONTEXT_ID            [dest], context_id);
+                      if (_param->_have_port_front_end_id)
+                      PORT_WRITE(out_WRITE_UNIT_IN_FRONT_END_ID          [dest], front_end_id);
+                      if (_param->_have_port_ooo_engine_id)
+                      PORT_WRITE(out_WRITE_UNIT_IN_OOO_ENGINE_ID         [dest], ooo_engine_id);
+                      if (_param->_have_port_rob_ptr  )
+                      PORT_WRITE(out_WRITE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_PACKET_ID             [i][j]));
+                  //  PORT_WRITE(out_WRITE_UNIT_IN_OPERATION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_OPERATION             [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_TYPE                  [dest], PORT_READ(in_EXECUTE_UNIT_OUT_TYPE                  [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RD              [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RD            [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_DATA_RD               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RD               [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_EXECUTE_UNIT_OUT_WRITE_RE              [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NUM_REG_RE            [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_DATA_RE               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_DATA_RE               [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_EXCEPTION             [dest], PORT_READ(in_EXECUTE_UNIT_OUT_EXCEPTION             [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_NO_SEQUENCE           [dest], PORT_READ(in_EXECUTE_UNIT_OUT_NO_SEQUENCE           [i][j]));
+                      PORT_WRITE(out_WRITE_UNIT_IN_ADDRESS               [dest], PORT_READ(in_EXECUTE_UNIT_OUT_ADDRESS               [i][j]));
+                    }
+                }
+            }
+          PORT_WRITE(out_EXECUTE_UNIT_OUT_ACK [i][j], ack);
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Execution_unit_to_Write_unit_transition.cpp

-              r81
+              r88
+      {
         // Flush routing_table
+        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_thread; j++)
+              _destination [i][j].clear();
+        for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+          for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+            for (uint32_t j=0; j<_param->_nb_thread; j++)
+              _destination [x][y][j].clear();
         // Fill routing table
+        for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+            // Test if link between src and dest
+            if (_param->_table_routing [i][j])
+              // Test the thread accepted by the execute_unit
+              for (uint32_t k=0; k<_param->_nb_thread; k++)
+                if (_param->_table_thread[j][k])
+                  // push_back == minor have a better priority
+                  _destination [i][k].push_back(j);
+        for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+          for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+            for (uint32_t j=0; j<_param->_nb_write_unit; j++)
+              // Test if link between src and dest
+              if (_param->_table_routing [x][y][j])
+                // Test the thread accepted by the execute_unit
+                for (uint32_t k=0; k<_param->_nb_thread; k++)
+                  if (_param->_table_thread[j][k])
+                    // push_back == minor have a better priority
+                    _destination [x][y][k].push_back(j);
+      }
     else
+      {
         if (_param->_priority == PRIORITY_ROUND_ROBIN)
+          for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+            for (uint32_t j=0; j<_param->_nb_thread; j++)
+              if (_destination [i][j].size() > 1)
+                {
+                  // Head queue became the Tail queue
+                  _destination [i][j].push_back(_destination [i][j].front());
+                  _destination [i][j].pop_front();
+                }
+          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              for (uint32_t j=0; j<_param->_nb_thread; j++)
+                if (_destination [x][y][j].size() > 1)
+                  {
+                    // Head queue became the Tail queue
+                    _destination [x][y][j].push_back(_destination [x][y][j].front());
+                    _destination [x][y][j].pop_front();
+                  }
+      }
 #if (DEBUG >= DEBUG_TRACE)
     // Print
     log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Routing Table");
+    for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+      for (uint32_t j=0; j<_param->_nb_thread; j++)
+        for (std::list<uint32_t>::iterator k=_destination[i][j].begin();
+             k != _destination[i][j].end();
+             k++)
+          log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"  * Execute_unit [%d], send at the write_unit [%d], the operation of thread [%d].",i,*k,j);
+    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+        for (uint32_t j=0; j<_param->_nb_thread; j++)
+          for (std::list<uint32_t>::iterator k=_destination[x][y][j].begin();
+               k != _destination[x][y][j].end();
+               k++)
+            log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"  * Execute_unit [%d][%d], send at the write_unit [%d], the operation of thread [%d].",x,y,*k,j);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/include/Parameters.h"
+#include "Common/include/Max.h"
 namespace morpheo {
 namespace behavioural {
 …
 #define FUNCTION "Execution_unit_to_Write_unit::Parameters"
   Parameters::Parameters (uint32_t    nb_execute_unit              ,
+                          uint32_t  * nb_execute_unit_port         ,//[nb_execute_unit]
                           uint32_t    nb_write_unit                ,
                           uint32_t    nb_context                   ,
 …
                           uint32_t    nb_special_register          ,
                           Tpriority_t priority                     ,
+                          bool     ** table_routing                ,
+                          bool     ** table_thread                 ):
+    _nb_execute_unit         (nb_execute_unit    ),
+    _nb_write_unit           (nb_write_unit      ),
+    _nb_context              (nb_context         ),
+    _nb_front_end            (nb_front_end       ),
+    _nb_ooo_engine           (nb_ooo_engine      ),
+    _nb_packet               (nb_packet          ),
+    _size_general_data       (size_general_data  ),
+    _size_special_data       (size_special_data  ),
+    _nb_general_register     (nb_general_register),
+    _nb_special_register     (nb_special_register),
+    _priority                (priority           ),
+    _size_context_id         (log2(nb_context         )),
+    _size_front_end_id       (log2(nb_front_end       )),
+    _size_ooo_engine_id      (log2(nb_ooo_engine      )),
+    _size_packet_id          (log2(nb_packet          )),
+    _size_general_register   (log2(nb_general_register)),
+    _size_special_register   (log2(nb_special_register)),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_packet_id     (_size_packet_id     > 0),
+    _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
+                          bool    *** table_routing                ,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+                          bool     ** table_thread                 ,//[nb_write_unit][nb_thread]
+                          bool        is_toplevel                  )
+  {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
+    _table_routing = table_routing ;
+    _table_thread  = table_thread  ;
+    _nb_execute_unit         = nb_execute_unit     ;
+    _nb_execute_unit_port    = nb_execute_unit_port;
+    _nb_write_unit           = nb_write_unit       ;
+    _nb_context              = nb_context          ;
+    _nb_front_end            = nb_front_end        ;
+    _nb_ooo_engine           = nb_ooo_engine       ;
+    _nb_packet               = nb_packet           ;
+    _nb_general_register     = nb_general_register ;
+    _nb_special_register     = nb_special_register ;
+    _priority                = priority            ;
+    _table_routing           = table_routing       ;
+    _table_thread            = table_thread        ;
+    _max_nb_execute_unit_port= max<uint32_t>(_nb_execute_unit_port, _nb_execute_unit);
+    _nb_thread               = get_nb_thread (nb_context, nb_front_end, nb_ooo_engine);
     test();
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(nb_context         );
+        _size_front_end_id       = log2(nb_front_end       );
+        _size_ooo_engine_id      = log2(nb_ooo_engine      );
+        _size_rob_ptr            = log2(nb_packet          );
+        _size_general_register   = log2(nb_general_register);
+        _size_special_register   = log2(nb_special_register);
+        _size_general_data       = size_general_data  ;
+        _size_special_data       = size_special_data  ;
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        copy();
+      }
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Execution_unit_to_Write_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param)
+//   {
+//     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Execution_unit_to_Write_unit::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _nb_execute_unit         (param._nb_execute_unit        ),
+    _nb_write_unit           (param._nb_write_unit          ),
+    _nb_context              (param._nb_context             ),
+    _nb_front_end            (param._nb_front_end           ),
+    _nb_ooo_engine           (param._nb_ooo_engine          ),
+    _nb_packet               (param._nb_packet              ),
+    _size_general_data       (param._size_general_data      ),
+    _size_special_data       (param._size_special_data      ),
+    _nb_general_register     (param._nb_general_register    ),
+    _nb_special_register     (param._nb_special_register    ),
+    _priority                (param._priority               ),
+    _size_context_id         (param._size_context_id        ),
+    _size_front_end_id       (param._size_front_end_id      ),
+    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+    _size_packet_id          (param._size_packet_id         ),
+    _size_general_register   (param._size_general_register  ),
+    _size_special_register   (param._size_special_register  ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_packet_id     (param._have_port_packet_id    ),
+    _nb_thread               (param._nb_thread              )
+#define FUNCTION "Execution_unit_to_Write_unit::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
-    _table_routing = param._table_routing ;
-    _table_thread  = param._table_thread  ;
-    test();
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Execution_unit_to_Write_unit::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Execution_unit_to_Write_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit/src/Parameters_msg_error.cpp

-              r81
+              r88
+  {
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"Begin");
+    Parameters_test test("Execution_unit_to_Write_unit");
+    bool is_link [_nb_execute_unit][_max_nb_execute_unit_port];
+    for (uint32_t i=0; i<_nb_execute_unit; i++)
+      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
+        is_link[i][j] = false;
+    for (uint32_t i=0; i<_nb_execute_unit; i++)
+      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
+        for (uint32_t k=0; k<_nb_write_unit; k++)
+          {
+            log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION,"[%d][%d][%d]",i,j,k);
+            if (_table_routing [i][j][k] == true)
+              {
+                log_printf(TRACE,Execution_unit_to_Write_unit,FUNCTION," * is link");
+    Parameters_test test("Execution_unit_to_Write_unit");
+                is_link [i][j] = true;
+                break;
+              }
+          }
     for (uint32_t i=0; i<_nb_execute_unit; i++)
+      {
+        uint32_t j;
+        for (j=0; j<_nb_write_unit; j++)
+          if (_table_routing [i][j] == true)
+            break;
+        if (j == _nb_write_unit)
+          test.error("The execute_unit ["+toString(i)+"] is link with none write_unit.");
+      }
+      for (uint32_t j=0; j<_nb_execute_unit_port[i]; j++)
+        if (not is_link[i][j])
+          test.error(toString(_("The execute_unit [%d][%d] is link with none write_unit.\n"),i,j));
     for (uint32_t i=0; i<_nb_write_unit; i++)
+      {
 …
           if (_table_thread [i][j] == true)
             break;
         if (j == _nb_thread)
           test.error("The write_unit ["+toString(i)+"] have none source's thread.");
+          test.error(toString(_("The write_unit [%d] have none source's thread.\n"),i));
+      }
     if ( (_priority != PRIORITY_STATIC     ) and
          (_priority != PRIORITY_ROUND_ROBIN))
       test.error("Unsupported priority scheme. It must be Static or Round Robin.");
+      test.error(_("Unsupported priority scheme. It must be Static or Round Robin.\n"));
     log_printf(FUNC,Execution_unit_to_Write_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Read_unit_to_Execution_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_min.cfg

-              r81
+              r88
 Read_unit_to_Execution_unit
        1       *2      # nb_read_unit
+       2       *2      # nb_execute_unit
+       1       +1      # nb_read_unit_port    [0] [nb_read_unit]
+       2       *2      # nb_execute_unit
+       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
        1       *2      # nb_context
        1       *2      # nb_front_end
 …
        4       *2      # size_load_queue
        1       +1      # priority
        1       +1      # table_routing        [0][0]
        1       +1      # table_routing        [0][1]
+       1       +1      # table_routing        [0][0][0]
+       1       +1      # table_routing        [0][1][0]
        0       +1      # table_execute_type   [0][TYPE_ALU    ]
        0       +1      # table_execute_type   [0][TYPE_SHIFT  ]
        0       +1      # table_execute_type   [0][TYPE_MOVE   ]
        0       +1      # table_execute_type   [0][TYPE_TEST   ]
+       0       +1      # table_execute_type   [0][TYPE_MUL_DIV]
+       0       +1      # table_execute_type   [0][TYPE_MUL    ]
+       0       +1      # table_execute_type   [0][TYPE_DIV    ]
        0       +1      # table_execute_type   [0][TYPE_EXTEND ]
        0       +1      # table_execute_type   [0][TYPE_FIND   ]
 …
        1       +1      # table_execute_type   [1][TYPE_MOVE   ]
        1       +1      # table_execute_type   [1][TYPE_TEST   ]
+       1       +1      # table_execute_type   [1][TYPE_MUL_DIV]
+       1       +1      # table_execute_type   [1][TYPE_MUL    ]
+       1       +1      # table_execute_type   [1][TYPE_DIV    ]
        1       +1      # table_execute_type   [1][TYPE_EXTEND ]
        1       +1      # table_execute_type   [1][TYPE_FIND   ]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-mono_thread.cfg

-              r81
+              r88
 Read_unit_to_Execution_unit
        3       *2      # nb_read_unit
+       1       +1      # nb_read_unit_port    [0] [nb_read_unit]
+       2       +1      # nb_read_unit_port    [1] [nb_read_unit]
+       4       +1      # nb_read_unit_port    [2] [nb_read_unit]
        4       *2      # nb_execute_unit
+       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
        1       *2      # nb_context
        1       *2      # nb_front_end
 …
        4       *4      # size_load_queue
        1       +1      # priority
        1       +1      # table_routing        [0][0]
        0       +1      # table_routing        [0][1]
        0       +1      # table_routing        [0][2]
        0       +1      # table_routing        [0][3]
        0       +1      # table_routing        [1][0]
        1       +1      # table_routing        [1][1]
        1       +1      # table_routing        [1][2]
        0       +1      # table_routing        [1][3]
        0       +1      # table_routing        [2][0]
        0       +1      # table_routing        [2][1]
        1       +1      # table_routing        [2][2]
        1       +1      # table_routing        [2][3]
+       1       +1      # table_routing        [0][0][0]
+       0       +1      # table_routing        [0][1][0]
+       0       +1      # table_routing        [0][2][0]
+       0       +1      # table_routing        [0][3][0]
+       0       +1      # table_routing        [1][0][0]
+       1       +1      # table_routing        [1][1][0]
+       1       +1      # table_routing        [1][2][0]
+       0       +1      # table_routing        [1][3][0]
+       0       +1      # table_routing        [2][0][0]
+       0       +1      # table_routing        [2][1][0]
+       1       +1      # table_routing        [2][2][0]
+       1       +1      # table_routing        [2][3][0]
        0       +1      # table_execute_type   [0][TYPE_ALU    ]
        0       +1      # table_execute_type   [0][TYPE_SHIFT  ]
        0       +1      # table_execute_type   [0][TYPE_MOVE   ]
        0       +1      # table_execute_type   [0][TYPE_TEST   ]
+       0       +1      # table_execute_type   [0][TYPE_MUL_DIV]
+       0       +1      # table_execute_type   [0][TYPE_MUL    ]
+       0       +1      # table_execute_type   [0][TYPE_DIV    ]
        0       +1      # table_execute_type   [0][TYPE_EXTEND ]
        0       +1      # table_execute_type   [0][TYPE_FIND   ]
 …
        1       +1      # table_execute_type   [1][TYPE_MOVE   ]
        1       +1      # table_execute_type   [1][TYPE_TEST   ]
+       1       +1      # table_execute_type   [1][TYPE_MUL_DIV]
+       1       +1      # table_execute_type   [1][TYPE_MUL    ]
+       1       +1      # table_execute_type   [1][TYPE_DIV    ]
        1       +1      # table_execute_type   [1][TYPE_EXTEND ]
        1       +1      # table_execute_type   [1][TYPE_FIND   ]
 …
        0       +1      # table_execute_type   [2][TYPE_MOVE   ]
        0       +1      # table_execute_type   [2][TYPE_TEST   ]
+       0       +1      # table_execute_type   [2][TYPE_MUL_DIV]
+       0       +1      # table_execute_type   [2][TYPE_MUL    ]
+       0       +1      # table_execute_type   [2][TYPE_DIV    ]
        0       +1      # table_execute_type   [2][TYPE_EXTEND ]
        0       +1      # table_execute_type   [2][TYPE_FIND   ]
 …
        1       +1      # table_execute_type   [3][TYPE_MOVE   ]
        1       +1      # table_execute_type   [3][TYPE_TEST   ]
+       0       +1      # table_execute_type   [3][TYPE_MUL_DIV]
+       0       +1      # table_execute_type   [3][TYPE_MUL    ]
+       0       +1      # table_execute_type   [3][TYPE_DIV    ]
        1       +1      # table_execute_type   [3][TYPE_EXTEND ]
        1       +1      # table_execute_type   [3][TYPE_FIND   ]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/config_multi_execute-multi_thread.cfg

-              r81
+              r88
 Read_unit_to_Execution_unit
        3       *2      # nb_read_unit
+       1       +1      # nb_read_unit_port    [0] [nb_read_unit]
+       1       +1      # nb_read_unit_port    [1] [nb_read_unit]
+       1       +1      # nb_read_unit_port    [2] [nb_read_unit]
        4       *2      # nb_execute_unit
+       1       +1      # nb_execute_unit_port [0] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [1] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [2] [nb_execute_unit]
+       1       +1      # nb_execute_unit_port [3] [nb_execute_unit]
        4       *2      # nb_context
        1       *2      # nb_front_end
 …
        4       *2      # size_load_queue
        1       +1      # priority
        1       +1      # table_routing        [0][0]
        0       +1      # table_routing        [0][1]
        0       +1      # table_routing        [0][2]
        0       +1      # table_routing        [0][3]
        0       +1      # table_routing        [1][0]
        1       +1      # table_routing        [1][1]
        1       +1      # table_routing        [1][2]
        0       +1      # table_routing        [1][3]
        0       +1      # table_routing        [2][0]
        0       +1      # table_routing        [2][1]
        1       +1      # table_routing        [2][2]
        1       +1      # table_routing        [2][3]
+       1       +1      # table_routing        [0][0][0]
+       0       +1      # table_routing        [0][1][0]
+       0       +1      # table_routing        [0][2][0]
+       0       +1      # table_routing        [0][3][0]
+       0       +1      # table_routing        [1][0][0]
+       1       +1      # table_routing        [1][1][0]
+       1       +1      # table_routing        [1][2][0]
+       0       +1      # table_routing        [1][3][0]
+       0       +1      # table_routing        [2][0][0]
+       0       +1      # table_routing        [2][1][0]
+       1       +1      # table_routing        [2][2][0]
+       1       +1      # table_routing        [2][3][0]
        0       +1      # table_execute_type   [0][TYPE_ALU    ]
        0       +1      # table_execute_type   [0][TYPE_SHIFT  ]
        0       +1      # table_execute_type   [0][TYPE_MOVE   ]
        0       +1      # table_execute_type   [0][TYPE_TEST   ]
+       0       +1      # table_execute_type   [0][TYPE_MUL_DIV]
+       0       +1      # table_execute_type   [0][TYPE_MUL    ]
+       0       +1      # table_execute_type   [0][TYPE_DIV    ]
        0       +1      # table_execute_type   [0][TYPE_EXTEND ]
        0       +1      # table_execute_type   [0][TYPE_FIND   ]
 …
        1       +1      # table_execute_type   [1][TYPE_MOVE   ]
        1       +1      # table_execute_type   [1][TYPE_TEST   ]
+       1       +1      # table_execute_type   [1][TYPE_MUL_DIV]
+       1       +1      # table_execute_type   [1][TYPE_MUL    ]
+       1       +1      # table_execute_type   [1][TYPE_DIV    ]
        1       +1      # table_execute_type   [1][TYPE_EXTEND ]
        1       +1      # table_execute_type   [1][TYPE_FIND   ]
 …
        0       +1      # table_execute_type   [2][TYPE_MOVE   ]
        0       +1      # table_execute_type   [2][TYPE_TEST   ]
+       0       +1      # table_execute_type   [2][TYPE_MUL_DIV]
+       0       +1      # table_execute_type   [2][TYPE_MUL    ]
+       0       +1      # table_execute_type   [2][TYPE_DIV    ]
        0       +1      # table_execute_type   [2][TYPE_EXTEND ]
        0       +1      # table_execute_type   [2][TYPE_FIND   ]
 …
        1       +1      # table_execute_type   [3][TYPE_MOVE   ]
        1       +1      # table_execute_type   [3][TYPE_TEST   ]
+       1       +1      # table_execute_type   [3][TYPE_MUL_DIV]
+       1       +1      # table_execute_type   [3][TYPE_MUL    ]
+       1       +1      # table_execute_type   [3][TYPE_DIV    ]
        0       +1      # table_execute_type   [3][TYPE_EXTEND ]
        0       +1      # table_execute_type   [3][TYPE_FIND   ]
 …
        0       +1      # table_execute_thread [3][1]
        0       +1      # table_execute_thread [3][2]
        1       +1      # table_execute_thread [3][3]
+       1       +1      # table_execute_thread [3][3]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/main.cpp

-              r81
+              r88
   err (_("list_params is :\n"));
   err (_("  * nb_read_unit                                         (uint32_t)\n"));
+  err (_("  * nb_read_unit_port    [nb_read_unit]                  (uint32_t)\n"));
   err (_("  * nb_execute_unit                                      (uint32_t)\n"));
+  err (_("  * nb_execute_unit_port [nb_execute_unit]               (uint32_t)\n"));
   err (_("  * nb_context                                           (uint32_t)\n"));
   err (_("  * nb_front_end                                         (uint32_t)\n"));
 …
   err (_("    * [TYPE_MOVE   ]\n"));
   err (_("    * [TYPE_TEST   ]\n"));
+  err (_("    * [TYPE_MUL_DIV]\n"));
+  err (_("    * [TYPE_MUL    ]\n"));
+  err (_("    * [TYPE_DIV    ]\n"));
   err (_("    * [TYPE_EXTEND ]\n"));
   err (_("    * [TYPE_FIND   ]\n"));
 …
   string      name                  =      argv[x++];
   uint32_t    _nb_read_unit         = atoi(argv[x++]);
+  if (static_cast<uint32_t>(argc) < 2+NB_PARAMS+_nb_read_unit)
+    usage (argc, argv);
+  uint32_t *  _nb_read_unit_port = new uint32_t [_nb_read_unit];
+  for (uint32_t i=0; i<_nb_read_unit; i++)
+    _nb_read_unit_port [i] = atoi(argv[x++]);
   uint32_t    _nb_execute_unit      = atoi(argv[x++]);
+  if (static_cast<uint32_t>(argc) < 2+NB_PARAMS+_nb_read_unit+_nb_execute_unit)
+    usage (argc, argv);
+  uint32_t    _sum_execute_unit_port = 0;
+  uint32_t *  _nb_execute_unit_port = new uint32_t [_nb_execute_unit];
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    {
+      _nb_execute_unit_port [i] = atoi(argv[x++]);
+      _sum_execute_unit_port += _nb_execute_unit_port [i];
+    }
   uint32_t    _nb_context           = atoi(argv[x++]);
   uint32_t    _nb_front_end         = atoi(argv[x++]);
 …
   uint32_t    _size_load_queue      = atoi(argv[x++]);
   Tpriority_t _priority             = fromString<Tpriority_t>(argv[x++]);
   uint32_t    _nb_thread            = get_nb_thread(_nb_context, _nb_front_end, _nb_ooo_engine);
+  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_read_unit*_nb_execute_unit)+(_nb_execute_unit*11)+(_nb_execute_unit*_nb_thread))
+    usage (argc, argv);
+  bool ** _table_routing        ;
+  bool ** _table_execute_type   ;
+  bool ** _table_execute_thread ;
+  _table_routing = new bool * [_nb_read_unit];
+  msg("%d\n",argc);
+  msg("%d\n",2+NB_PARAMS+(_nb_read_unit+_nb_execute_unit+(_nb_read_unit*_sum_execute_unit_port)+(_nb_execute_unit*12)+(_nb_execute_unit*_nb_thread)));
+  if (static_cast<uint32_t>(argc) != 2+NB_PARAMS+(_nb_read_unit+_nb_execute_unit+(_nb_read_unit*_sum_execute_unit_port)+(_nb_execute_unit*12)+(_nb_execute_unit*_nb_thread)))
+      usage (argc, argv);
+  bool *** _table_routing        ;
+  bool  ** _table_execute_type   ;
+  bool  ** _table_execute_thread ;
+  _table_routing = new bool ** [_nb_read_unit];
   for (uint32_t i=0; i<_nb_read_unit; i++)
+    {
       _table_routing [i] = new bool [_nb_execute_unit];
+      _table_routing [i] = new bool * [_nb_execute_unit];
       for (uint32_t j=0; j<_nb_execute_unit; j++)
+        _table_routing [i][j] = atoi(argv[x++]);
+    }
+        {
+          _table_routing [i][j] = new bool [_nb_execute_unit_port [j]];
+          for (uint32_t k=0; k<_nb_execute_unit_port [j]; k++)
+            _table_routing [i][j][k] = atoi(argv[x++]);
+        }
+    }
   _table_execute_type = new bool * [_nb_execute_unit];
   for (uint32_t i=0; i<_nb_execute_unit; i++)
 …
       _table_execute_type [i][TYPE_MOVE   ] = atoi(argv[x++]);
       _table_execute_type [i][TYPE_TEST   ] = atoi(argv[x++]);
+      _table_execute_type [i][TYPE_MUL_DIV] = atoi(argv[x++]);
+      _table_execute_type [i][TYPE_MUL    ] = atoi(argv[x++]);
+      _table_execute_type [i][TYPE_DIV    ] = atoi(argv[x++]);
       _table_execute_type [i][TYPE_EXTEND ] = atoi(argv[x++]);
       _table_execute_type [i][TYPE_FIND   ] = atoi(argv[x++]);
 …
       morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
         (_nb_read_unit         ,
+         _nb_read_unit_port    ,
          _nb_execute_unit      ,
+         _nb_execute_unit_port ,
          _nb_context           ,
          _nb_front_end         ,
 …
          _table_routing        ,
          _table_execute_type   ,
+         _table_execute_thread
+         _table_execute_thread ,
+         true // is_toplevel
          );
 …
+    }
+  delete [] _table_routing        ;
+  delete [] _nb_read_unit_port;
+  delete [] _nb_execute_unit_port ;
+  for (uint32_t i=0; i<_nb_read_unit; i++)
+    {
+      for (uint32_t j=0; j<_nb_execute_unit; j++)
+        delete [] _table_routing [i][j];
+      delete [] _table_routing [i];
+    }
+  delete [] _table_routing;
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    delete [] _table_execute_type [i];
   delete [] _table_execute_type   ;
+  for (uint32_t i=0; i<_nb_execute_unit; i++)
+    delete [] _table_execute_thread [i];
   delete [] _table_execute_thread ;
   return (EXIT_SUCCESS);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Read_unit_to_Execution_unit * _Read_unit_to_Execution_unit = new Read_unit_to_Execution_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ," in_READ_UNIT_OUT_VAL"                  ,Tcontrol_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,"out_READ_UNIT_OUT_ACK"                  ,Tcontrol_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ," in_READ_UNIT_OUT_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ," in_READ_UNIT_OUT_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ," in_READ_UNIT_OUT_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ," in_READ_UNIT_OUT_PACKET_ID"            ,Tpacket_t         ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ," in_READ_UNIT_OUT_OPERATION"            ,Toperation_t      ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ," in_READ_UNIT_OUT_TYPE"                 ,Ttype_t           ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE," in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ," in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ," in_READ_UNIT_OUT_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ," in_READ_UNIT_OUT_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ," in_READ_UNIT_OUT_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ," in_READ_UNIT_OUT_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ," in_READ_UNIT_OUT_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ," in_READ_UNIT_OUT_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ," in_READ_UNIT_OUT_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ," in_READ_UNIT_OUT_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ," in_READ_UNIT_OUT_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_read_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,"out_EXECUTE_UNIT_IN_VAL"                  ,Tcontrol_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ," in_EXECUTE_UNIT_IN_ACK"                  ,Tcontrol_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"out_EXECUTE_UNIT_IN_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"out_EXECUTE_UNIT_IN_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"out_EXECUTE_UNIT_IN_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,"out_EXECUTE_UNIT_IN_PACKET_ID"            ,Tpacket_t         ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,"out_EXECUTE_UNIT_IN_OPERATION"            ,Toperation_t      ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,"out_EXECUTE_UNIT_IN_TYPE"                 ,Ttype_t           ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"out_EXECUTE_UNIT_IN_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"out_EXECUTE_UNIT_IN_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,"out_EXECUTE_UNIT_IN_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,"out_EXECUTE_UNIT_IN_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,"out_EXECUTE_UNIT_IN_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,"out_EXECUTE_UNIT_IN_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"out_EXECUTE_UNIT_IN_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,"out_EXECUTE_UNIT_IN_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_execute_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"out_EXECUTE_UNIT_IN_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_execute_unit);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ," in_READ_UNIT_OUT_VAL"                  ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,"out_READ_UNIT_OUT_ACK"                  ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ," in_READ_UNIT_OUT_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ," in_READ_UNIT_OUT_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ," in_READ_UNIT_OUT_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ," in_READ_UNIT_OUT_PACKET_ID"            ,Tpacket_t         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ," in_READ_UNIT_OUT_OPERATION"            ,Toperation_t      ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ," in_READ_UNIT_OUT_TYPE"                 ,Ttype_t           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE," in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ," in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ," in_READ_UNIT_OUT_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ," in_READ_UNIT_OUT_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ," in_READ_UNIT_OUT_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ," in_READ_UNIT_OUT_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ," in_READ_UNIT_OUT_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ," in_READ_UNIT_OUT_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ," in_READ_UNIT_OUT_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ," in_READ_UNIT_OUT_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ," in_READ_UNIT_OUT_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,"out_EXECUTE_UNIT_IN_VAL"                  ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ," in_EXECUTE_UNIT_IN_ACK"                  ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"out_EXECUTE_UNIT_IN_CONTEXT_ID"           ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"out_EXECUTE_UNIT_IN_FRONT_END_ID"         ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"out_EXECUTE_UNIT_IN_OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,"out_EXECUTE_UNIT_IN_PACKET_ID"            ,Tpacket_t         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,"out_EXECUTE_UNIT_IN_OPERATION"            ,Toperation_t      ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,"out_EXECUTE_UNIT_IN_TYPE"                 ,Ttype_t           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"out_EXECUTE_UNIT_IN_HAS_IMMEDIAT"         ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"out_EXECUTE_UNIT_IN_IMMEDIAT"             ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,"out_EXECUTE_UNIT_IN_DATA_RA"              ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,"out_EXECUTE_UNIT_IN_DATA_RB"              ,Tgeneral_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,"out_EXECUTE_UNIT_IN_DATA_RC"              ,Tspecial_data_t   ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,"out_EXECUTE_UNIT_IN_WRITE_RD"             ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"out_EXECUTE_UNIT_IN_NUM_REG_RD"           ,Tgeneral_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,"out_EXECUTE_UNIT_IN_WRITE_RE"             ,Tcontrol_t        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  ALLOC2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"out_EXECUTE_UNIT_IN_NUM_REG_RE"           ,Tspecial_address_t,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
 …
   (*(_Read_unit_to_Execution_unit->in_NRESET))       (*(in_NRESET));
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_front_end_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit);
   if (_param->_have_port_packet_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  if (_param->_have_port_rob_ptr  )
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
   if (_param->_have_port_load_queue_ptr)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit, in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit, in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_front_end_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit);
   if (_param->_have_port_packet_id)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  if (_param->_have_port_rob_ptr  )
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   if (_param->_have_port_load_queue_ptr)
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit);
   INSTANCE1_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Read_unit_to_Execution_unit,out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
   for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+    for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+      if (_param->_table_routing[i][j])
+        for (uint32_t k=0; k<_param->_nb_thread; k++)
+          if (_param->_table_execute_thread[j][k])
+            {
+              read_unit_thread [i].insert(k);
+              for (uint32_t l=0; l<_param->_nb_type; l++)
+                if (_param->_table_execute_type[j][l])
+                  read_unit_type [i][k].insert(l);
+            }
+    for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+      for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+        if (_param->_table_routing[i][x][y])
+          for (uint32_t k=0; k<_param->_nb_thread; k++)
+            if (_param->_table_execute_thread[x][k])
+              {
+                read_unit_thread [i].insert(k);
+                for (uint32_t l=0; l<_param->_nb_type; l++)
+                  if (_param->_table_execute_type[x][l])
+                    read_unit_type [i][k].insert(l);
+              }
   //bool ** _table_routing       ; //array [nb_read_unit][nb_execute_unit]
   //bool ** _table_execute_type  ; //array [nb_execute_unit][nb_type]
 …
       LABEL("Iteration %d",iteration);
       list<entry_t> request [_param->_nb_read_unit];
+      list<entry_t> request [_param->_nb_read_unit][_param->_max_nb_read_unit_port];
       uint32_t nb_request_in;
       for (nb_request_in=0; nb_request_in < _param->_nb_packet; )
         for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+          {
+            if (nb_request_in >= _param->_nb_packet)
+              break;
+            Tcontext_t context_id   ;
+            Tcontext_t front_end_id ;
+            Tcontext_t ooo_engine_id;
+            Tcontext_t num_thread   ;
+            // Find compatible thread
+            do
+              {
+                context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
+                front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
+                ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
+                num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
+                                                front_end_id , _param->_size_front_end_id ,
+                                                ooo_engine_id, _param->_size_ooo_engine_id);
+              }
+            while (read_unit_thread[i].find(num_thread) == read_unit_thread[i].end());
+            Ttype_t    type;
+            // Find a compatible type
+            do
+              {
+                type = range<Ttype_t> (rand(), _param->_size_type);
+              }
+            while (read_unit_type[i][num_thread].find(type) == read_unit_type[i][num_thread].end());
+            request[i].push_back(entry_t (context_id   ,
+                                          front_end_id ,
+                                          ooo_engine_id,
+                                          nb_request_in,
+                                          range<Toperation_t      > (rand(), _param->_size_operation       ),
+                                          type,
+                                          range<Tlsq_ptr_t        > (rand(), _param->_size_store_queue     ),
+                                          range<Tlsq_ptr_t        > (rand(), _param->_size_load_queue      ),
+                                          range<Tcontrol_t        > (rand(), 2                             ),
+                                          range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                          range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                          range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                          range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
+                                          range<Tcontrol_t        > (rand(), 2                             ),
+                                          range<Tgeneral_address_t> (rand(), _param->_size_general_register),
+                                          range<Tcontrol_t        > (rand(), 2                             ),
+                                          range<Tspecial_address_t> (rand(), _param->_size_special_register)
+                                          ));
+            nb_request_in++;
+          }
+          for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
+            {
+              if (nb_request_in >= _param->_nb_packet)
+                break;
+              Tcontext_t context_id   ;
+              Tcontext_t front_end_id ;
+              Tcontext_t ooo_engine_id;
+              Tcontext_t num_thread   ;
+              // Find compatible thread
+              do
+                {
+                  context_id    = range<Tcontext_t> (rand(), _param->_size_context_id   );
+                  front_end_id  = range<Tcontext_t> (rand(), _param->_size_front_end_id );
+                  ooo_engine_id = range<Tcontext_t> (rand(), _param->_size_ooo_engine_id);
+                  num_thread    = get_num_thread (context_id   , _param->_size_context_id   ,
+                                                  front_end_id , _param->_size_front_end_id ,
+                                                  ooo_engine_id, _param->_size_ooo_engine_id);
+                }
+              while (read_unit_thread[i].find(num_thread) == read_unit_thread[i].end());
+              Ttype_t    type;
+              // Find a compatible type
+              do
+                {
+                  type = range<Ttype_t> (rand(), _param->_size_type);
+                }
+              while (read_unit_type[i][num_thread].find(type) == read_unit_type[i][num_thread].end());
+              request[i][j].push_back(entry_t (context_id   ,
+                                               front_end_id ,
+                                               ooo_engine_id,
+                                               nb_request_in,
+                                               range<Toperation_t      > (rand(), _param->_size_operation       ),
+                                               type,
+                                               range<Tlsq_ptr_t        > (rand(), (1<<_param->_size_store_queue_ptr)),
+                                               range<Tlsq_ptr_t        > (rand(), (1<<_param->_size_load_queue_ptr )),
+                                               range<Tcontrol_t        > (rand(), 2                             ),
+                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                               range<Tgeneral_data_t   > (rand(), _param->_size_general_data    ),
+                                               range<Tspecial_data_t   > (rand(), _param->_size_special_data    ),
+                                               range<Tcontrol_t        > (rand(), 2                             ),
+                                               range<Tgeneral_address_t> (rand(), _param->_size_general_register),
+                                               range<Tcontrol_t        > (rand(), 2                             ),
+                                               range<Tspecial_address_t> (rand(), _param->_size_special_register)
+                                               ));
+              nb_request_in++;
+            }
       uint32_t   nb_request_out = 0;
 …
+        {
           for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+            {
+              bool val = not request[i].empty() and ((rand()%100) < percent_transaction_in);
+            for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
+              {
+                bool val = not request[i][j].empty() and ((rand()%100) < percent_transaction_in);
               in_READ_UNIT_OUT_VAL [i]->write(val);
               if (val)
+                in_READ_UNIT_OUT_VAL [i][j]->write(val);
+                if (val)
+                {
                   in_READ_UNIT_OUT_CONTEXT_ID           [i] ->write(request[i].front()._context_id           );
                   in_READ_UNIT_OUT_FRONT_END_ID         [i] ->write(request[i].front()._front_end_id         );
                   in_READ_UNIT_OUT_OOO_ENGINE_ID        [i] ->write(request[i].front()._ooo_engine_id        );
                   in_READ_UNIT_OUT_PACKET_ID            [i] ->write(request[i].front()._packet_id            );
                   in_READ_UNIT_OUT_OPERATION            [i] ->write(request[i].front()._operation            );
                   in_READ_UNIT_OUT_TYPE                 [i] ->write(request[i].front()._type                 );
                   in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i] ->write(request[i].front()._store_queue_ptr_write);
+                  in_READ_UNIT_OUT_CONTEXT_ID           [i][j] ->write(request[i][j].front()._context_id           );
+                  in_READ_UNIT_OUT_FRONT_END_ID         [i][j] ->write(request[i][j].front()._front_end_id         );
+                  in_READ_UNIT_OUT_OOO_ENGINE_ID        [i][j] ->write(request[i][j].front()._ooo_engine_id        );
+                  in_READ_UNIT_OUT_PACKET_ID            [i][j] ->write(request[i][j].front()._packet_id            );
+                  in_READ_UNIT_OUT_OPERATION            [i][j] ->write(request[i][j].front()._operation            );
+                  in_READ_UNIT_OUT_TYPE                 [i][j] ->write(request[i][j].front()._type                 );
+                  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE[i][j] ->write(request[i][j].front()._store_queue_ptr_write);
                   if (_param->_have_port_load_queue_ptr)
                   in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i] ->write(request[i].front()._load_queue_ptr_write );
                   in_READ_UNIT_OUT_HAS_IMMEDIAT         [i] ->write(request[i].front()._has_immediat         );
                   in_READ_UNIT_OUT_IMMEDIAT             [i] ->write(request[i].front()._immediat             );
                   in_READ_UNIT_OUT_DATA_RA              [i] ->write(request[i].front()._data_ra              );
                   in_READ_UNIT_OUT_DATA_RB              [i] ->write(request[i].front()._data_rb              );
                   in_READ_UNIT_OUT_DATA_RC              [i] ->write(request[i].front()._data_rc              );
                   in_READ_UNIT_OUT_WRITE_RD             [i] ->write(request[i].front()._write_rd             );
                   in_READ_UNIT_OUT_NUM_REG_RD           [i] ->write(request[i].front()._num_reg_rd           );
                   in_READ_UNIT_OUT_WRITE_RE             [i] ->write(request[i].front()._write_re             );
                   in_READ_UNIT_OUT_NUM_REG_RE           [i] ->write(request[i].front()._num_reg_re           );
+                  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [i][j] ->write(request[i][j].front()._load_queue_ptr_write );
+                  in_READ_UNIT_OUT_HAS_IMMEDIAT         [i][j] ->write(request[i][j].front()._has_immediat         );
+                  in_READ_UNIT_OUT_IMMEDIAT             [i][j] ->write(request[i][j].front()._immediat             );
+                  in_READ_UNIT_OUT_DATA_RA              [i][j] ->write(request[i][j].front()._data_ra              );
+                  in_READ_UNIT_OUT_DATA_RB              [i][j] ->write(request[i][j].front()._data_rb              );
+                  in_READ_UNIT_OUT_DATA_RC              [i][j] ->write(request[i][j].front()._data_rc              );
+                  in_READ_UNIT_OUT_WRITE_RD             [i][j] ->write(request[i][j].front()._write_rd             );
+                  in_READ_UNIT_OUT_NUM_REG_RD           [i][j] ->write(request[i][j].front()._num_reg_rd           );
+                  in_READ_UNIT_OUT_WRITE_RE             [i][j] ->write(request[i][j].front()._write_re             );
+                  in_READ_UNIT_OUT_NUM_REG_RE           [i][j] ->write(request[i][j].front()._num_reg_re           );
+                }
+            }
+              }
           for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+            in_EXECUTE_UNIT_IN_ACK [i]->write((rand()%100) < percent_transaction_out);
+            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+              in_EXECUTE_UNIT_IN_ACK [i][j]->write((rand()%100) < percent_transaction_out);
           SC_START(0);
           for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+            if (in_READ_UNIT_OUT_VAL [i]->read() and out_READ_UNIT_OUT_ACK [i]->read())
+              {
+                LABEL("READ_UNIT_OUT   [%d] - Transaction accepted",i);
+              }
+            for (uint32_t j=0; j<_param->_nb_read_unit_port [i]; j++)
+              if (in_READ_UNIT_OUT_VAL [i][j]->read() and out_READ_UNIT_OUT_ACK [i][j]->read())
+                {
+                  LABEL("READ_UNIT_OUT   [%d][%d] - Transaction accepted",i,j);
+                }
           for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+            if (out_EXECUTE_UNIT_IN_VAL [i]->read() and in_EXECUTE_UNIT_IN_ACK [i]->read())
+              {
+                LABEL("EXECUTE_UNIT_IN [%d] - Transaction accepted (%d)",i,nb_request_out);
+                nb_request_out ++;
+                Tpacket_t packet = (_param->_have_port_packet_id)?out_EXECUTE_UNIT_IN_PACKET_ID[i]->read():0;
+                LABEL("  * packet           : %d",packet);
+                uint32_t read_unit;
+                // find read_unit
+                for (read_unit=0; read_unit<_param->_nb_read_unit; read_unit++)
+                  if (packet == ((_param->_have_port_packet_id)?request[read_unit].front()._packet_id:0))
+                    break;
+                LABEL("  * read_unit source : %d",read_unit);
+                if (_param->_have_port_packet_id)
+                TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_PACKET_ID            [i]->read(), request[read_unit].front()._packet_id            );
+                // Authorised link ? read_unit -> execute_unit
+                TEST(bool, _param->_table_routing[read_unit][i], true);
+                if (_param->_have_port_context_id)
+                TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_CONTEXT_ID           [i]->read(), request[read_unit].front()._context_id           );
+                if (_param->_have_port_front_end_id)
+                TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_FRONT_END_ID         [i]->read(), request[read_unit].front()._front_end_id         );
+                if (_param->_have_port_ooo_engine_id)
+                TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        [i]->read(), request[read_unit].front()._ooo_engine_id        );
+                TEST(Toperation_t      ,out_EXECUTE_UNIT_IN_OPERATION            [i]->read(), request[read_unit].front()._operation            );
+                TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i]->read(), request[read_unit].front()._type                 );
+                TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i]->read(), request[read_unit].front()._store_queue_ptr_write);
+                if (_param->_have_port_load_queue_ptr)
+                TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i]->read(), request[read_unit].front()._load_queue_ptr_write );
+                TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i]->read(), request[read_unit].front()._has_immediat         );
+                TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_IMMEDIAT             [i]->read(), request[read_unit].front()._immediat             );
+                TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RA              [i]->read(), request[read_unit].front()._data_ra              );
+                TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RB              [i]->read(), request[read_unit].front()._data_rb              );
+                TEST(Tspecial_data_t   ,out_EXECUTE_UNIT_IN_DATA_RC              [i]->read(), request[read_unit].front()._data_rc              );
+                TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RD             [i]->read(), request[read_unit].front()._write_rd             );
+                TEST(Tgeneral_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RD           [i]->read(), request[read_unit].front()._num_reg_rd           );
+                TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RE             [i]->read(), request[read_unit].front()._write_re             );
+                TEST(Tspecial_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RE           [i]->read(), request[read_unit].front()._num_reg_re           );
+                request[read_unit].pop_front();
+              }
+            for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+              if (out_EXECUTE_UNIT_IN_VAL [i][j]->read() and in_EXECUTE_UNIT_IN_ACK [i][j]->read())
+                {
+                  LABEL("EXECUTE_UNIT_IN [%d][%d] - Transaction accepted (%d)",i,j,nb_request_out);
+                  nb_request_out ++;
+                  Tpacket_t packet = (_param->_have_port_rob_ptr  )?out_EXECUTE_UNIT_IN_PACKET_ID[i][j]->read():0;
+                  LABEL("  * packet           : %d",packet);
+                  uint32_t x;
+                  uint32_t y;
+                  // find read_unit
+                  bool find = false;
+                  for (x=0; x<_param->_nb_read_unit; x++)
+                    {
+                      for (y=0; y<_param->_nb_read_unit_port[x]; y++)
+                        if (packet == ((_param->_have_port_rob_ptr  )?request[x][y].front()._packet_id:0))
+                          {
+                            find = true;
+                            break;
+                          }
+                      if (find)
+                        break;
+                    }
+                  LABEL("  * read_unit source : [%d][%d]",x,y);
+                  if (_param->_have_port_rob_ptr  )
+                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_PACKET_ID            [i][j]->read(), request[x][y].front()._packet_id            );
+                  // Authorised link ? read_unit -> execute_unit
+                  TEST(bool, _param->_table_routing[x][i][j], true);
+                  if (_param->_have_port_context_id)
+                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_CONTEXT_ID           [i][j]->read(), request[x][y].front()._context_id           );
+                  if (_param->_have_port_front_end_id)
+                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_FRONT_END_ID         [i][j]->read(), request[x][y].front()._front_end_id         );
+                  if (_param->_have_port_ooo_engine_id)
+                  TEST(Tcontext_t        ,out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        [i][j]->read(), request[x][y].front()._ooo_engine_id        );
+                  TEST(Toperation_t      ,out_EXECUTE_UNIT_IN_OPERATION            [i][j]->read(), request[x][y].front()._operation            );
+                  TEST(Ttype_t           ,out_EXECUTE_UNIT_IN_TYPE                 [i][j]->read(), request[x][y].front()._type                 );
+                  TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE[i][j]->read(), request[x][y].front()._store_queue_ptr_write);
+                  if (_param->_have_port_load_queue_ptr)
+                  TEST(Tlsq_ptr_t        ,out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j]->read(), request[x][y].front()._load_queue_ptr_write );
+                  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         [i][j]->read(), request[x][y].front()._has_immediat         );
+                  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_IMMEDIAT             [i][j]->read(), request[x][y].front()._immediat             );
+                  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RA              [i][j]->read(), request[x][y].front()._data_ra              );
+                  TEST(Tgeneral_data_t   ,out_EXECUTE_UNIT_IN_DATA_RB              [i][j]->read(), request[x][y].front()._data_rb              );
+                  TEST(Tspecial_data_t   ,out_EXECUTE_UNIT_IN_DATA_RC              [i][j]->read(), request[x][y].front()._data_rc              );
+                  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RD             [i][j]->read(), request[x][y].front()._write_rd             );
+                  TEST(Tgeneral_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RD           [i][j]->read(), request[x][y].front()._num_reg_rd           );
+                  TEST(Tcontrol_t        ,out_EXECUTE_UNIT_IN_WRITE_RE             [i][j]->read(), request[x][y].front()._write_re             );
+                  TEST(Tspecial_address_t,out_EXECUTE_UNIT_IN_NUM_REG_RE           [i][j]->read(), request[x][y].front()._num_reg_re           );
+                  request[x][y].pop_front();
+                }
           SC_START(1);
+        }
+    }
 …
   delete in_CLOCK;
   delete in_NRESET;
+  delete []  in_READ_UNIT_OUT_VAL                  ;
+  delete [] out_READ_UNIT_OUT_ACK                  ;
+  delete []  in_READ_UNIT_OUT_CONTEXT_ID           ;
+  delete []  in_READ_UNIT_OUT_FRONT_END_ID         ;
+  delete []  in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
+  delete []  in_READ_UNIT_OUT_PACKET_ID            ;
+  delete []  in_READ_UNIT_OUT_OPERATION            ;
+  delete []  in_READ_UNIT_OUT_TYPE                 ;
+  delete []  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
+  delete []  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
+  delete []  in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
+  delete []  in_READ_UNIT_OUT_IMMEDIAT             ;
+  delete []  in_READ_UNIT_OUT_DATA_RA              ;
+  delete []  in_READ_UNIT_OUT_DATA_RB              ;
+  delete []  in_READ_UNIT_OUT_DATA_RC              ;
+  delete []  in_READ_UNIT_OUT_WRITE_RD             ;
+  delete []  in_READ_UNIT_OUT_NUM_REG_RD           ;
+  delete []  in_READ_UNIT_OUT_WRITE_RE             ;
+  delete []  in_READ_UNIT_OUT_NUM_REG_RE           ;
+  delete [] out_EXECUTE_UNIT_IN_VAL                  ;
+  delete []  in_EXECUTE_UNIT_IN_ACK                  ;
+  delete [] out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
+  delete [] out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
+  delete [] out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
+  delete [] out_EXECUTE_UNIT_IN_PACKET_ID            ;
+  delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
+  delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
+  delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
+  delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
+  delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
+  delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
+  delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
+  delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
+  delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
+  delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
+  delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
+  delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
+  delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_VAL                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_READ_UNIT_OUT_ACK                  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_PACKET_ID            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_OPERATION            ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_TYPE                 ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RA              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RB              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_DATA_RC              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RD             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_WRITE_RE             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE           ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
+  DELETE2_SC_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,_param->_nb_execute_unit,_param->_nb_execute_unit_port[it1]);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
+  public : const uint32_t    _nb_read_unit           ;
+  public : const uint32_t    _nb_execute_unit        ;
+  public : const uint32_t    _nb_context             ;
+  public : const uint32_t    _nb_front_end           ;
+  public : const uint32_t    _nb_ooo_engine          ;
+  public : const uint32_t    _nb_packet              ;
+  public : const uint32_t    _size_general_data      ;
+  public : const uint32_t    _size_special_data      ;
+  public : const uint32_t    _nb_general_register    ;
+  public : const uint32_t    _nb_special_register    ;
+  public : const uint32_t    _size_store_queue       ;
+  public : const uint32_t    _size_load_queue        ;
+  public : const Tpriority_t _priority               ;
+  public :       bool     ** _table_routing          ; //[nb_read_unit][nb_execute_unit]
+  public :       bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
+  public :       bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
+  public : uint32_t    _nb_read_unit           ;
+  public : uint32_t  * _nb_read_unit_port      ;//[nb_read_unit]
+  public : uint32_t    _nb_execute_unit        ;
+  public : uint32_t  * _nb_execute_unit_port   ;//[nb_execute_unit]
+  public : uint32_t    _nb_context             ;
+  public : uint32_t    _nb_front_end           ;
+  public : uint32_t    _nb_ooo_engine          ;
+  public : uint32_t    _nb_packet              ;
+//public : uint32_t    _size_general_data      ;
+//public : uint32_t    _size_special_data      ;
+  public : uint32_t    _nb_general_register    ;
+  public : uint32_t    _nb_special_register    ;
+//public : uint32_t    _size_store_queue       ;
+//public : uint32_t    _size_load_queue        ;
+  public : Tpriority_t _priority               ;
+  public : bool    *** _table_routing          ; //[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
+  public : bool     ** _table_execute_type     ; //[nb_execute_unit][nb_type]
+  public : bool     ** _table_execute_thread   ; //[nb_execute_unit][nb_thread]
+  public : const uint32_t    _size_context_id        ;
+  public : const uint32_t    _size_front_end_id      ;
+  public : const uint32_t    _size_ooo_engine_id     ;
+  public : const uint32_t    _size_packet_id         ;
+  public : const uint32_t    _size_general_register  ;
+  public : const uint32_t    _size_special_register  ;
+  public : uint32_t    _max_nb_read_unit_port  ;
+  public : uint32_t    _max_nb_execute_unit_port;
+//public : uint32_t    _size_context_id        ;
+//public : uint32_t    _size_front_end_id      ;
+//public : uint32_t    _size_ooo_engine_id     ;
+//public : uint32_t    _size_packet_id         ;
+//public : uint32_t    _size_general_register  ;
+//public : uint32_t    _size_special_register  ;
   public : const bool        _have_port_context_id   ;
   public : const bool        _have_port_front_end_id ;
   public : const bool        _have_port_ooo_engine_id;
   public : const bool        _have_port_packet_id    ;
   public : const bool        _have_port_load_queue_ptr;
+//public : bool        _have_port_context_id   ;
+//public : bool        _have_port_front_end_id ;
+//public : bool        _have_port_ooo_engine_id;
+//public : bool        _have_port_packet_id    ;
+//public : bool        _have_port_load_queue_ptr;
   public : const uint32_t    _nb_thread              ;
   public :       uint32_t    _nb_load_store_unit     ;
   public :       uint32_t    _nb_functionnal_unit    ;
+  public : uint32_t    _nb_thread              ;
+  public : uint32_t    _nb_load_store_unit     ;
+  public : uint32_t    _nb_functionnal_unit    ;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t    nb_read_unit           ,
+                        uint32_t  * nb_read_unit_port      ,
                         uint32_t    nb_execute_unit        ,
+                        uint32_t  * nb_execute_unit_port   ,
                         uint32_t    nb_context             ,
                         uint32_t    nb_front_end           ,
 …
                         uint32_t    size_load_queue        ,
                         Tpriority_t priority               ,
                         bool     ** table_routing          ,
+                        bool    *** table_routing          ,
                         bool     ** table_execute_type     ,
+                        bool     ** table_execute_thread   );
+  public : Parameters  (Parameters & param) ;
+                        bool     ** table_execute_thread   ,
+                        bool        is_toplevel=false      );
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h

-              r82
+              r88
 namespace read_unit_to_execution_unit {
+  class destination_t
+  {
+  public : uint32_t grp;
+  public : uint32_t elt;
+  public : destination_t (uint32_t grp, uint32_t elt)
+    {
+      this->grp = grp;
+      this->elt = elt;
+    }
+  };
   class Read_unit_to_Execution_unit
 …
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_VAL                  ;
   public    : SC_OUT(Tcontrol_t        )   ** out_READ_UNIT_OUT_ACK                  ;
   public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_CONTEXT_ID           ;
   public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_FRONT_END_ID         ;
   public    : SC_IN (Tcontext_t        )   **  in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
   public    : SC_IN (Tpacket_t         )   **  in_READ_UNIT_OUT_PACKET_ID            ;
   public    : SC_IN (Toperation_t      )   **  in_READ_UNIT_OUT_OPERATION            ;
   public    : SC_IN (Ttype_t           )   **  in_READ_UNIT_OUT_TYPE                 ;
   public    : SC_IN (Tlsq_ptr_t        )   **  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
   public    : SC_IN (Tlsq_ptr_t        )   **  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
   public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_IMMEDIAT             ;
   public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_DATA_RA              ;
   public    : SC_IN (Tgeneral_data_t   )   **  in_READ_UNIT_OUT_DATA_RB              ;
   public    : SC_IN (Tspecial_data_t   )   **  in_READ_UNIT_OUT_DATA_RC              ;
   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_WRITE_RD             ;
   public    : SC_IN (Tgeneral_address_t)   **  in_READ_UNIT_OUT_NUM_REG_RD           ;
   public    : SC_IN (Tcontrol_t        )   **  in_READ_UNIT_OUT_WRITE_RE             ;
   public    : SC_IN (Tspecial_address_t)   **  in_READ_UNIT_OUT_NUM_REG_RE           ;
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_VAL                    ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_READ_UNIT_OUT_ACK                    ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_CONTEXT_ID             ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_FRONT_END_ID           ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_READ_UNIT_OUT_OOO_ENGINE_ID          ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tpacket_t         )  ***  in_READ_UNIT_OUT_PACKET_ID              ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Toperation_t      )  ***  in_READ_UNIT_OUT_OPERATION              ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Ttype_t           )  ***  in_READ_UNIT_OUT_TYPE                   ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tlsq_ptr_t        )  ***  in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE  ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tlsq_ptr_t        )  ***  in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE   ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_HAS_IMMEDIAT           ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_IMMEDIAT               ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_DATA_RA                ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_data_t   )  ***  in_READ_UNIT_OUT_DATA_RB                ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tspecial_data_t   )  ***  in_READ_UNIT_OUT_DATA_RC                ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_WRITE_RD               ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tgeneral_address_t)  ***  in_READ_UNIT_OUT_NUM_REG_RD             ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_READ_UNIT_OUT_WRITE_RE               ;//[nb_read_unit][nb_read_unit_port]
+  public    : SC_IN (Tspecial_address_t)  ***  in_READ_UNIT_OUT_NUM_REG_RE             ;//[nb_read_unit][nb_read_unit_port]
     // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_VAL                  ;
   public    : SC_IN (Tcontrol_t        )   **  in_EXECUTE_UNIT_IN_ACK                  ;
   public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
   public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
   public    : SC_OUT(Tcontext_t        )   ** out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
   public    : SC_OUT(Tpacket_t         )   ** out_EXECUTE_UNIT_IN_PACKET_ID            ;
   public    : SC_OUT(Toperation_t      )   ** out_EXECUTE_UNIT_IN_OPERATION            ;
   public    : SC_OUT(Ttype_t           )   ** out_EXECUTE_UNIT_IN_TYPE                 ;
   public    : SC_OUT(Tlsq_ptr_t        )   ** out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
   public    : SC_OUT(Tlsq_ptr_t        )   ** out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_IMMEDIAT             ;
   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RA              ;
   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RB              ;
   public    : SC_OUT(Tspecial_data_t   )   ** out_EXECUTE_UNIT_IN_DATA_RC              ;
   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_WRITE_RD             ;
   public    : SC_OUT(Tgeneral_address_t)   ** out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_UNIT_IN_WRITE_RE             ;
   public    : SC_OUT(Tspecial_address_t)   ** out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_VAL                  ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_EXECUTE_UNIT_IN_ACK                  ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_CONTEXT_ID           ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_FRONT_END_ID         ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tpacket_t         )  *** out_EXECUTE_UNIT_IN_PACKET_ID            ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Toperation_t      )  *** out_EXECUTE_UNIT_IN_OPERATION            ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Ttype_t           )  *** out_EXECUTE_UNIT_IN_TYPE                 ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tlsq_ptr_t        )  *** out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tlsq_ptr_t        )  *** out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_IMMEDIAT             ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RA              ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RB              ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tspecial_data_t   )  *** out_EXECUTE_UNIT_IN_DATA_RC              ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_WRITE_RD             ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tgeneral_address_t)  *** out_EXECUTE_UNIT_IN_NUM_REG_RD           ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_EXECUTE_UNIT_IN_WRITE_RE             ;//[nb_execute_unit][nb_execute_unit_port]
+  public    : SC_OUT(Tspecial_address_t)  *** out_EXECUTE_UNIT_IN_NUM_REG_RE           ;//[nb_execute_unit][nb_execute_unit_port]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   private   : std::list<uint32_t> *** _destination; // [nb_read_unit][nb_thread][nb_type];
+  private   : std::list<destination_t> *** _destination; // [nb_read_unit][nb_thread][nb_type];
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Parameters.h"
+#include "Common/include/Max.h"
 namespace morpheo {
 …
 #define FUNCTION "Read_unit_to_Execution_unit::Parameters"
   Parameters::Parameters (uint32_t    nb_read_unit           ,
+                          uint32_t  * nb_read_unit_port      ,
                           uint32_t    nb_execute_unit        ,
+                          uint32_t  * nb_execute_unit_port   ,
                           uint32_t    nb_context             ,
                           uint32_t    nb_front_end           ,
 …
                           uint32_t    size_load_queue        ,
                           Tpriority_t priority               ,
                           bool     ** table_routing          ,
+                          bool    *** table_routing          ,
                           bool     ** table_execute_type     ,
+                          bool     ** table_execute_thread   ):
+    _nb_read_unit            (nb_read_unit       ),
+    _nb_execute_unit         (nb_execute_unit    ),
+    _nb_context              (nb_context         ),
+    _nb_front_end            (nb_front_end       ),
+    _nb_ooo_engine           (nb_ooo_engine      ),
+    _nb_packet               (nb_packet          ),
+    _size_general_data       (size_general_data  ),
+    _size_special_data       (size_special_data  ),
+    _nb_general_register     (nb_general_register),
+    _nb_special_register     (nb_special_register),
+    _size_store_queue        (size_store_queue   ),
+    _size_load_queue         (size_load_queue    ),
+    _priority                (priority           ),
+    _size_context_id         (log2(nb_context         )),
+    _size_front_end_id       (log2(nb_front_end       )),
+    _size_ooo_engine_id      (log2(nb_ooo_engine      )),
+    _size_packet_id          (log2(nb_packet          )),
+    _size_general_register   (log2(nb_general_register)),
+    _size_special_register   (log2(nb_special_register)),
+    _have_port_context_id    (_size_context_id    > 0),
+    _have_port_front_end_id  (_size_front_end_id  > 0),
+    _have_port_ooo_engine_id (_size_ooo_engine_id > 0),
+    _have_port_packet_id     (_size_packet_id     > 0),
+    _have_port_load_queue_ptr(_size_load_queue    > 1),
+    _nb_thread               (get_nb_thread (nb_context, nb_front_end, nb_ooo_engine))
+                          bool     ** table_execute_thread   ,
+                          bool        is_toplevel            )
+  {
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
+    _table_routing        = table_routing       ;
+    _table_execute_type   = table_execute_type  ;
+    _table_execute_thread = table_execute_thread;
+    _nb_read_unit            = nb_read_unit        ;
+    _nb_read_unit_port       = nb_read_unit_port   ;
+    _nb_execute_unit         = nb_execute_unit     ;
+    _nb_execute_unit_port    = nb_execute_unit_port;
+    _nb_context              = nb_context          ;
+    _nb_front_end            = nb_front_end        ;
+    _nb_ooo_engine           = nb_ooo_engine       ;
+    _nb_packet               = nb_packet           ;
+    _nb_general_register     = nb_general_register ;
+    _nb_special_register     = nb_special_register ;
+    _priority                = priority            ;
+    _table_routing           = table_routing       ;
+    _table_execute_type      = table_execute_type  ;
+    _table_execute_thread    = table_execute_thread;
+    _nb_load_store_unit   = 0;
+    _max_nb_read_unit_port   = max<uint32_t>(_nb_read_unit_port, _nb_read_unit);
+    _max_nb_execute_unit_port= max<uint32_t>(_nb_execute_unit_port, _nb_execute_unit);
+    _nb_thread               = get_nb_thread (nb_context, nb_front_end, nb_ooo_engine);
+    _nb_load_store_unit      = 0;
     for (uint32_t i=0; i<nb_execute_unit; i++)
 …
     test();
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(nb_context         );
+        _size_front_end_id       = log2(nb_front_end       );
+        _size_ooo_engine_id      = log2(nb_ooo_engine      );
+        _size_rob_ptr            = log2(nb_packet          );
+        _size_general_register   = log2(nb_general_register);
+        _size_special_register   = log2(nb_special_register);
+        _size_general_data       = size_general_data   ;
+        _size_special_data       = size_special_data   ;
+        _size_store_queue_ptr    = log2(size_store_queue   );
+        _size_load_queue_ptr     = log2(size_load_queue    );
+        _have_port_context_id    = _size_context_id    > 0;
+        _have_port_front_end_id  = _size_front_end_id  > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        _have_port_rob_ptr       = _size_rob_ptr       > 0;
+        _have_port_load_queue_ptr= _size_load_queue_ptr> 0;
+        copy();
+      }
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Read_unit_to_Execution_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param)
+//   {
+//     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Read_unit_to_Execution_unit::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _nb_read_unit            (param._nb_read_unit           ),
+    _nb_execute_unit         (param._nb_execute_unit        ),
+    _nb_context              (param._nb_context             ),
+    _nb_front_end            (param._nb_front_end           ),
+    _nb_ooo_engine           (param._nb_ooo_engine          ),
+    _nb_packet               (param._nb_packet              ),
+    _size_general_data       (param._size_general_data      ),
+    _size_special_data       (param._size_special_data      ),
+    _nb_general_register     (param._nb_general_register    ),
+    _nb_special_register     (param._nb_special_register    ),
+    _size_store_queue        (param._size_store_queue       ),
+    _size_load_queue         (param._size_load_queue        ),
+    _priority                (param._priority               ),
+    _size_context_id         (param._size_context_id        ),
+    _size_front_end_id       (param._size_front_end_id      ),
+    _size_ooo_engine_id      (param._size_ooo_engine_id     ),
+    _size_packet_id          (param._size_packet_id         ),
+    _size_general_register   (param._size_general_register  ),
+    _size_special_register   (param._size_special_register  ),
+    _have_port_context_id    (param._have_port_context_id   ),
+    _have_port_front_end_id  (param._have_port_front_end_id ),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id),
+    _have_port_packet_id     (param._have_port_packet_id    ),
+    _have_port_load_queue_ptr(param._have_port_load_queue_ptr),
+    _nb_thread               (param._nb_thread              )
+#define FUNCTION "Read_unit_to_Execution_unit::~Parameters"
+  Parameters::~Parameters ()
+  {
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
-    _table_routing        = param._table_routing       ;
-    _table_execute_type   = param._table_execute_type  ;
-    _table_execute_thread = param._table_execute_thread;
-    _nb_load_store_unit   = param._nb_load_store_unit  ;
-    _nb_functionnal_unit  = param._nb_functionnal_unit ;
-    test();
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Read_unit_to_Execution_unit::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Read_unit_to_Execution_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_msg_error.cpp

-              r81
+              r88
     // TYPE_MOVE    |     X     |            |            | cmov is optionnal
     // TYPE_TEST    |     X     |            |            |
+    // TYPE_MUL_DIV |     X     |            |            | div is optionnal
+    // TYPE_MUL     |     X     |            |            |
+    // TYPE_DIV     |     X     |     X      |            |
     // TYPE_EXTEND  |     X     |     X      |            |
     // TYPE_FIND    |     X     |     X      |            |
 …
     type_valid     [TYPE_MOVE   ] = true;
     type_valid     [TYPE_TEST   ] = true;
+    type_valid     [TYPE_MUL_DIV] = true;
+    type_valid     [TYPE_MUL    ] = true;
+    type_valid     [TYPE_DIV    ] = true;
     type_valid     [TYPE_EXTEND ] = true;
     type_valid     [TYPE_FIND   ] = true;
 …
     type_uniq      [TYPE_MEMORY ] = true;
+    type_optionnal [TYPE_DIV    ] = true;
     type_optionnal [TYPE_EXTEND ] = true;
     type_optionnal [TYPE_FIND   ] = true;
 …
         if (_table_execute_thread [i][j] == true)
           // this execute_unit execute this thread !
+          for (Ttype_t k=0; k<=_nb_type; k++)
+            if (_table_execute_type[i][k] == true)
+              {
+                // Test uniq type
+                if (type_present [j][k] and type_uniq[k])
+                  test.error("The execute_unit '"+toString(i)+"' can execute operation of type '"+toString_type(k)+"' at the thread '"+toString(j)+"'. But an another execute_unit can be execute the same type for the same thread. And the type must be uniq !.");
+                type_present [j][k] = true;
+              }
+          for (Ttype_t k=0; k<_nb_type; k++)
+            if (_table_execute_type[i][k] == true)
+              {
+//                 test.information(toString(_("Execute_unit [%d], Thread [%d], Type [%d], type_valid %d, type_present %d, type_uniq %d\n"),i,j,k,type_valid[k],type_present[j][k],type_uniq[k]));
+                // Test uniq type
+                if (type_present [j][k] and type_uniq[k])
+                  test.error(toString(_("The execute_unit '%d' can execute operation of type '%s' at the thread '%d'. But an another execute_unit can be execute the same type for the same thread. And the type must be single !.\n"),i,toString_type(k).c_str(),j));
+                type_present [j][k] = true;
+              }
+    for (Ttype_t j=0; j<_nb_type; j++)
+      if (not type_valid [j])
+        for (uint32_t i=0; i<_nb_thread; i++)
+          if (type_present [i][j])
+            test.error(toString(_("The thread '%d' can execute the type's operation '%s' but this type is invalid.\n"),i,toString_type(j).c_str()));
     for (Ttype_t j=0; j<_nb_type; j++)
 …
         for (uint32_t i=0; i<_nb_thread; i++)
           if (not type_present [i][j])
             test.error("The thread '"+toString(i)+"' can't access at the execute_unit to execute the type's operation '"+toString_type(j)+"' (and this type is not optionnal !).");
+            test.error(toString(_("The thread '%d' can't access at the execute_unit to execute the type's operation '%s' (and this type is not optional !).\n"),i,toString_type(j).c_str()));
     // Test all excluve type
     for (uint32_t i=0; i<_nb_execute_unit; i++)
       for (Ttype_t j=0; j<=_nb_type; j++)
+      for (Ttype_t j=0; j<_nb_type; j++)
         if (type_exclusive [j] and _table_execute_type[i][j])
           for (Ttype_t k=0; k<=_nb_type; k++)
+          for (Ttype_t k=0; k<_nb_type; k++)
             if ((j != k) and (_table_execute_type[i][k] == true))
+              {
                 test.error("The execute_unit ["+toString(i)+"] implement the type '"+toString_type(j)+"', and this type is exclusive with all others type.");
+                test.error(toString(_("The execute_unit [%d] implement the type '%s', and this type is exclusive with all others type.\n"),i,toString_type(j).c_str()));
                 break;
+              }
 …
         if (j == _nb_thread)
           test.error("The execute_unit ["+toString(i)+"] have none source's thread.");
+          test.error(toString(_("The execute_unit [%d] have none source's thread.\n"),i));
+      }
     if ( (_priority != PRIORITY_STATIC     ) and
          (_priority != PRIORITY_ROUND_ROBIN))
       test.error("Unsupported priority scheme. It must be Static or Round Robin.");
+      test.error(_("Unsupported priority scheme. It must be Static or Round Robin.\n"));
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Parameters_print.cpp

-              r81
+              r88
     xml.singleton_begin("nb_general_register"); xml.attribut("value",toString(_nb_general_register)); xml.singleton_end();
     xml.singleton_begin("nb_special_register"); xml.attribut("value",toString(_nb_special_register)); xml.singleton_end();
     xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
     xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
+//  xml.singleton_begin("size_store_queue   "); xml.attribut("value",toString(_size_store_queue   )); xml.singleton_end();
+//  xml.singleton_begin("size_load_queue    "); xml.attribut("value",toString(_size_load_queue    )); xml.singleton_end();
     xml.singleton_begin("priority           "); xml.attribut("value",toString(_priority           )); xml.singleton_end();
     xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
+#if DEBUG_Read_unit_to_Execution_unit == true
+    log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Method - transition");
 …
         for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+          {
+            sensitive << (*(in_READ_UNIT_OUT_VAL                   [i]))
+                      << (*(in_READ_UNIT_OUT_OPERATION             [i]))
+                      << (*(in_READ_UNIT_OUT_TYPE                  [i]))
+                      << (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]))
+                      << (*(in_READ_UNIT_OUT_IMMEDIAT              [i]))
+                      << (*(in_READ_UNIT_OUT_DATA_RA               [i]))
+                      << (*(in_READ_UNIT_OUT_DATA_RB               [i]))
+                      << (*(in_READ_UNIT_OUT_DATA_RC               [i]))
+                      << (*(in_READ_UNIT_OUT_WRITE_RD              [i]))
+                      << (*(in_READ_UNIT_OUT_NUM_REG_RD            [i]))
+                      << (*(in_READ_UNIT_OUT_WRITE_RE              [i]))
+                      << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i]))
+                      << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
+            if (_param->_have_port_load_queue_ptr)
+            sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
+            if (_param->_have_port_context_id)
+            sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
+            if (_param->_have_port_front_end_id)
+            sensitive  << (*(in_READ_UNIT_OUT_FRONT_END_ID          [i]));
+            if (_param->_have_port_ooo_engine_id)
+            sensitive  << (*(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i]));
+            if (_param->_have_port_packet_id)
+            sensitive  << (*(in_READ_UNIT_OUT_PACKET_ID             [i]));
+          }
+          for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
+            {
+              sensitive << (*(in_READ_UNIT_OUT_VAL                   [i][j]))
+                        << (*(in_READ_UNIT_OUT_OPERATION             [i][j]))
+                        << (*(in_READ_UNIT_OUT_TYPE                  [i][j]))
+                        << (*(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i][j]))
+                        << (*(in_READ_UNIT_OUT_IMMEDIAT              [i][j]))
+                        << (*(in_READ_UNIT_OUT_DATA_RA               [i][j]))
+                        << (*(in_READ_UNIT_OUT_DATA_RB               [i][j]))
+                        << (*(in_READ_UNIT_OUT_DATA_RC               [i][j]))
+                        << (*(in_READ_UNIT_OUT_WRITE_RD              [i][j]))
+                        << (*(in_READ_UNIT_OUT_NUM_REG_RD            [i][j]))
+                        << (*(in_READ_UNIT_OUT_WRITE_RE              [i][j]))
+                        << (*(in_READ_UNIT_OUT_NUM_REG_RE            [i][j]))
+                        << (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i][j]));
+              if (_param->_have_port_load_queue_ptr)
+              sensitive  << (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i][j]));
+              if (_param->_have_port_context_id)
+              sensitive  << (*(in_READ_UNIT_OUT_CONTEXT_ID            [i][j]));
+              if (_param->_have_port_front_end_id)
+              sensitive  << (*(in_READ_UNIT_OUT_FRONT_END_ID          [i][j]));
+              if (_param->_have_port_ooo_engine_id)
+              sensitive  << (*(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i][j]));
+              if (_param->_have_port_rob_ptr  )
+              sensitive  << (*(in_READ_UNIT_OUT_PACKET_ID             [i][j]));
+            }
         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          sensitive << (*(in_EXECUTE_UNIT_IN_ACK                 [i]));
+          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+            sensitive << (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
         for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
+          {
             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_VAL           [i]));
             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_TYPE          [i]));
+            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_VAL           [i][j]));
+            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_TYPE          [i][j]));
             if (_param->_have_port_context_id)
             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [i]));
+            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [i][j]));
             if (_param->_have_port_front_end_id)
             (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [i]));
+            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [i][j]));
             if (_param->_have_port_ooo_engine_id)
+            (*(out_READ_UNIT_OUT_ACK [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [i]));
+            for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+              (*(out_READ_UNIT_OUT_ACK [i])) (*(in_EXECUTE_UNIT_IN_ACK [j]));
+            (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [i][j]));
+            for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              (*(out_READ_UNIT_OUT_ACK [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [x][y]));
+          }
         for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+          {
+            (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_VAL [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+            (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_VAL [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             if (_param->_have_port_context_id)
+              {
+            (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+            (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_CONTEXT_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
 …
             if (_param->_have_port_front_end_id)
+              {
+            (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+            (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_FRONT_END_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
 …
             if (_param->_have_port_ooo_engine_id)
+              {
+            (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+              }
+            if (_param->_have_port_packet_id)
+              {
+            (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_PACKET_ID     [j]));
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+              }
+            (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_OPERATION     [j]));
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_TYPE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [j]));
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_VAL                   [j]));
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_TYPE                  [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID            [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID          [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+            (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
+            if (_param->_have_port_rob_ptr  )
+              {
+            (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_PACKET_ID     [x][y]));
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_PACKET_ID [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+              }
+            (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_OPERATION     [x][y]));
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_OPERATION [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_TYPE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [x][y]));
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_VAL                   [x][y]));
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_TYPE                  [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID            [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID          [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
             if (_param->_have_port_load_queue_ptr)
+              {
+            (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [j]));
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_VAL                  [j]));
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_TYPE                 [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID           [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID         [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [j]));
+            (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE [x][y]));
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_VAL                  [x][y]));
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_TYPE                 [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID           [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID         [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID        [x][y]));
+              }
+              }
+            (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_HAS_IMMEDIAT  [j]));
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_IMMEDIAT      [j]));
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_DATA_RA       [j]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_DATA_RB       [j]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_DATA_RC       [j]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_WRITE_RD      [j]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+            (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_HAS_IMMEDIAT  [x][y]));
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_IMMEDIAT      [x][y]));
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_IMMEDIAT [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_DATA_RA       [x][y]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RA [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_DATA_RB       [x][y]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RB [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_DATA_RC       [x][y]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_DATA_RC [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_WRITE_RD      [x][y]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RD [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_NUM_REG_RD    [j]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_WRITE_RE      [j]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+              }
+            (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_EXECUTE_UNIT_IN_ACK [i]));
+            for (uint32_t j=0; j<_param->_nb_read_unit; j++)
+              {
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_NUM_REG_RE    [j]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_VAL           [j]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_TYPE          [j]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [j]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [j]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [j]));
+            (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_NUM_REG_RD    [x][y]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RD [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_WRITE_RE      [x][y]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_WRITE_RE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+            (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_EXECUTE_UNIT_IN_ACK [i][j]));
+            for (uint32_t x=0; x<_param->_nb_read_unit; x++)
+              for (uint32_t y=0; y<_param->_nb_read_unit_port[x]; y++)
+              {
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_NUM_REG_RE    [x][y]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_VAL           [x][y]));
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_TYPE          [x][y]));
+                if (_param->_have_port_context_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_CONTEXT_ID    [x][y]));
+                if (_param->_have_port_front_end_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_FRONT_END_ID  [x][y]));
+                if (_param->_have_port_ooo_engine_id)
+                (*(out_EXECUTE_UNIT_IN_NUM_REG_RE [i][j])) (*(in_READ_UNIT_OUT_OOO_ENGINE_ID [x][y]));
+              }
+          }
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Read_unit_to_Execution_unit,FUNCTION,"Generate Statistics file");

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

-              r81
+              r88
     // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit", _param->_nb_read_unit);
+       ALLOC2_INTERFACE("read_unit_out", IN, EAST, "Output of read_unit",_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       ALLOC1_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL);
+       ALLOC1_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_packet_id);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
+       ALLOC1_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
+       _ALLOC2_VALACK_IN ( in_READ_UNIT_OUT_VAL,VAL,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_VALACK_OUT(out_READ_UNIT_OUT_ACK,ACK,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id       ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id    ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_rob_ptr          ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation        ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type             ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue_ptr  ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr   ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data     ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_READ_UNIT_OUT_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register ,_param->_nb_read_unit,_param->_nb_read_unit_port[it1]);
+     }
     // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit);
+       ALLOC2_INTERFACE("execute_unit_in", OUT, WEST, "Input of execute_unit", _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       ALLOC1_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL);
+       ALLOC1_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK);
+       _ALLOC2_VALACK_OUT(out_EXECUTE_UNIT_IN_VAL,VAL, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_VALACK_IN ( in_EXECUTE_UNIT_IN_ACK,ACK, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id       , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id    , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_rob_ptr          , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation        , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1                              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,_param->_size_store_queue_ptr  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,_param->_size_load_queue_ptr   , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data     , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+       _ALLOC2_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1]);
+     }
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_CONTEXT_ID           ,"CONTEXT_ID"           ,Tcontext_t        ,_param->_size_context_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_FRONT_END_ID         ,"FRONT_END_ID"         ,Tcontext_t        ,_param->_size_front_end_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ,"OOO_ENGINE_ID"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_PACKET_ID            ,"PACKET_ID"            ,Tpacket_t         ,_param->_size_packet_id);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_OPERATION            ,"OPERATION"            ,Toperation_t      ,_param->_size_operation);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_TYPE                 ,"TYPE"                 ,Ttype_t           ,_param->_size_type);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ,"HAS_IMMEDIAT"         ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RC              ,"DATA_RC"              ,Tspecial_data_t   ,_param->_size_special_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RD             ,"WRITE_RD"             ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_WRITE_RE             ,"WRITE_RE"             ,Tcontrol_t        ,1);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RE           ,"NUM_REG_RE"           ,Tspecial_address_t,_param->_size_special_register);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE,"STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t        ,log2(_param->_size_store_queue));
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ,"LOAD_QUEUE_PTR_WRITE" ,Tlsq_ptr_t        ,log2(_param->_size_load_queue));
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_IMMEDIAT             ,"IMMEDIAT"             ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RA              ,"DATA_RA"              ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_DATA_RB              ,"DATA_RB"              ,Tgeneral_data_t   ,_param->_size_general_data);
-       ALLOC1_SIGNAL_OUT(out_EXECUTE_UNIT_IN_NUM_REG_RD           ,"NUM_REG_RD"           ,Tgeneral_address_t,_param->_size_general_register);
+     }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     _destination = new std::list<uint32_t> ** [_param->_nb_read_unit];
+     if (usage_is_set(_usage,USE_SYSTEMC))
+       {
+     _destination = new std::list<destination_t> ** [_param->_nb_read_unit];
      for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+       {
          _destination [i] = new std::list<uint32_t> * [_param->_nb_thread];
+         _destination [i] = new std::list<destination_t> * [_param->_nb_thread];
          for (uint32_t j=0; j<_param->_nb_thread; j++)
+           {
              _destination [i][j] = new std::list<uint32_t> [_param->_nb_type];
+             _destination [i][j] = new std::list<destination_t> [_param->_nb_type];
+           }
+       }
+       }
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

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

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/include/Read_unit_to_Execution_unit.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
         delete    in_NRESET;
+        // ~~~~~[ Interface "read_unit_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] in_READ_UNIT_OUT_VAL                  ;
+        delete []out_READ_UNIT_OUT_ACK                  ;
+        if (_param->_have_port_context_id)
+        delete [] in_READ_UNIT_OUT_CONTEXT_ID           ;
+        if (_param->_have_port_front_end_id)
+        delete [] in_READ_UNIT_OUT_FRONT_END_ID         ;
+        if (_param->_have_port_ooo_engine_id)
+        delete [] in_READ_UNIT_OUT_OOO_ENGINE_ID        ;
+        if (_param->_have_port_packet_id)
+        delete [] in_READ_UNIT_OUT_PACKET_ID            ;
+        delete [] in_READ_UNIT_OUT_OPERATION            ;
+        delete [] in_READ_UNIT_OUT_TYPE                 ;
+        delete [] in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE;
+        if (_param->_have_port_load_queue_ptr)
+        delete [] in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE ;
+        delete [] in_READ_UNIT_OUT_HAS_IMMEDIAT         ;
+        delete [] in_READ_UNIT_OUT_IMMEDIAT             ;
+        delete [] in_READ_UNIT_OUT_DATA_RA              ;
+        delete [] in_READ_UNIT_OUT_DATA_RB              ;
+        delete [] in_READ_UNIT_OUT_DATA_RC              ;
+        delete [] in_READ_UNIT_OUT_WRITE_RD             ;
+        delete [] in_READ_UNIT_OUT_NUM_REG_RD           ;
+        delete [] in_READ_UNIT_OUT_WRITE_RE             ;
+        delete [] in_READ_UNIT_OUT_NUM_REG_RE           ;
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_VAL                    , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_READ_UNIT_OUT_ACK                    , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_CONTEXT_ID             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_context_id       );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_FRONT_END_ID           , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_front_end_id     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_OOO_ENGINE_ID          , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_ooo_engine_id    );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_PACKET_ID              , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_rob_ptr          );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_OPERATION              , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_operation        );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_TYPE                   , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_type             );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE  , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_store_queue_ptr  );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE   , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_load_queue_ptr   );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_HAS_IMMEDIAT           , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_IMMEDIAT               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RA                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RB                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_DATA_RC                , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_special_data     );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_WRITE_RD               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RD             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_general_register );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_WRITE_RE               , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_READ_UNIT_OUT_NUM_REG_RE             , _param->_nb_read_unit, _param->_nb_read_unit_port [it1],_param->_size_special_register );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_VAL                  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL( in_EXECUTE_UNIT_IN_ACK                  , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_CONTEXT_ID           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_context_id       );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_FRONT_END_ID         , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_front_end_id     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_ooo_engine_id    );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_PACKET_ID            , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_rob_ptr          );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_OPERATION            , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_operation        );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_TYPE                 , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_type             );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RC              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_special_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RD             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_WRITE_RE             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],1                              );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RE           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_special_register );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE, _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_store_queue_ptr  );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_load_queue_ptr   );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_IMMEDIAT             , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RA              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_DATA_RB              , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_data     );
+         DELETE2_SIGNAL(out_EXECUTE_UNIT_IN_NUM_REG_RD           , _param->_nb_execute_unit, _param->_nb_execute_unit_port [it1],_param->_size_general_register );
+        // ~~~~~[ Interface "execute_unit_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] out_EXECUTE_UNIT_IN_VAL                  ;
+        delete []  in_EXECUTE_UNIT_IN_ACK                  ;
+        if (_param->_have_port_context_id)
+        delete [] out_EXECUTE_UNIT_IN_CONTEXT_ID           ;
+        if (_param->_have_port_front_end_id)
+        delete [] out_EXECUTE_UNIT_IN_FRONT_END_ID         ;
+        if (_param->_have_port_ooo_engine_id)
+        delete [] out_EXECUTE_UNIT_IN_OOO_ENGINE_ID        ;
+        if (_param->_have_port_packet_id)
+        delete [] out_EXECUTE_UNIT_IN_PACKET_ID            ;
+        delete [] out_EXECUTE_UNIT_IN_OPERATION            ;
+        delete [] out_EXECUTE_UNIT_IN_TYPE                 ;
+        delete [] out_EXECUTE_UNIT_IN_HAS_IMMEDIAT         ;
+        delete [] out_EXECUTE_UNIT_IN_DATA_RC              ;
+        delete [] out_EXECUTE_UNIT_IN_WRITE_RD             ;
+        delete [] out_EXECUTE_UNIT_IN_WRITE_RE             ;
+        delete [] out_EXECUTE_UNIT_IN_NUM_REG_RE           ;
+        delete [] out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE;
+        if (_param->_have_port_load_queue_ptr)
+        delete [] out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE ;
+        delete [] out_EXECUTE_UNIT_IN_IMMEDIAT             ;
+        delete [] out_EXECUTE_UNIT_IN_DATA_RA              ;
+        delete [] out_EXECUTE_UNIT_IN_DATA_RB              ;
+        delete [] out_EXECUTE_UNIT_IN_NUM_REG_RD           ;
+         delete [] _destination;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] _destination;
     delete    _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_genMealy.cpp

-              r81
+              r88
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"Begin");
     bool execute_unit_use [_param->_nb_execute_unit];
+    bool execute_unit_use [_param->_nb_execute_unit][_param->_max_nb_execute_unit_port];
     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+      execute_unit_use[i] = (PORT_READ(in_EXECUTE_UNIT_IN_ACK [i]) == 0);
+      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+        execute_unit_use[i][j] = false;
     for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+      {
+        bool       ack = false;
+      for (uint32_t j=0; j<_param->_nb_read_unit_port[i]; j++)
+        {
+          bool       ack = false;
+          log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Test Read_unit[%d][%d]",i,j);
+          if (PORT_READ(in_READ_UNIT_OUT_VAL [i][j]) == true)
+            {
+              log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION," * have a valid entry.");
+              Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID    [i][j]):0;
+              Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID  [i][j]):0;
+              Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID [i][j]):0;
+              Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
+                                                        front_end_id , _param->_size_front_end_id ,
+                                                        ooo_engine_id, _param->_size_ooo_engine_id);
+              Ttype_t    type          = PORT_READ(in_READ_UNIT_OUT_TYPE [i][j]);
+#ifdef DEBUG_TEST
+              if (_destination[i][num_thread][type].empty())
+                throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no execute_unit to receive a operation from the read_unit ["+toString(i)+"], thread ["+toString(num_thread)+"] and a operation's type ["+toString_type(type)+"].");
+#endif
+              // find a free execute_unit
+              for (std::list<destination_t>::iterator it=_destination[i][num_thread][type].begin();
+                   (it != _destination[i][num_thread][type].end()) and (ack == false);
+                   it++)
+                {
+                  uint32_t dest = (*it).grp;
+                  uint32_t port = (*it).elt;
+                  log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"   * Test destination [%d][%d].",dest,port);
+                  if (execute_unit_use [dest][port] == false)
+                    {
+                      log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"     * Is ok! Link.");
+                      // have find !!!
+                      ack                           = PORT_READ(in_EXECUTE_UNIT_IN_ACK [dest][port]);
+                      execute_unit_use [dest][port] = true;
+        log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"Test Read_unit[%d]",i);
+        if (PORT_READ(in_READ_UNIT_OUT_VAL [i]) == true)
+          {
+            log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION," * have a valid entry.");
+            Tcontext_t context_id    = (_param->_have_port_context_id   )?PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID    [i]):0;
+            Tcontext_t front_end_id  = (_param->_have_port_front_end_id )?PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID  [i]):0;
+            Tcontext_t ooo_engine_id = (_param->_have_port_ooo_engine_id)?PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID [i]):0;
+            Tcontext_t num_thread    = get_num_thread(context_id   , _param->_size_context_id   ,
+                                                      front_end_id , _param->_size_front_end_id ,
+                                                      ooo_engine_id, _param->_size_ooo_engine_id);
+            Ttype_t    type          = PORT_READ(in_READ_UNIT_OUT_TYPE [i]);
+#ifdef DEBUG_TEST
+            if (_destination[i][num_thread][type].empty())
+              throw ERRORMORPHEO(FUNCTION,"Invalid Operation : They have no execute_unit to receive a operation from the read_unit ["+toString(i)+"], thread ["+toString(num_thread)+"] and a operation's type ["+toString_type(type)+"].");
+#endif
+            // find a free execute_unit
+            for (std::list<uint32_t>::iterator it=_destination[i][num_thread][type].begin();
+                 (it != _destination[i][num_thread][type].end()) and (ack == false);
+                 it++)
+              {
+                uint32_t dest = *it;
+                log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"   * Test destination [%d].",dest);
+                if (execute_unit_use [dest] == false)
+                  {
+                    log_printf(TRACE,Read_unit_to_Execution_unit,FUNCTION,"     * Is ok! Link.");
+                    // have find !!!
+                    ack                     = true;
+                    execute_unit_use [dest] = true;
+                    if (_param->_have_port_context_id)
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_CONTEXT_ID            [dest], PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID            [i]));
+                    if (_param->_have_port_front_end_id)
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_FRONT_END_ID          [dest], PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID          [i]));
+                    if (_param->_have_port_ooo_engine_id)
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID         [dest], PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i]));
+                    if (_param->_have_port_packet_id)
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_PACKET_ID             [dest], PORT_READ(in_READ_UNIT_OUT_PACKET_ID             [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i]));
+                    if (_param->_have_port_load_queue_ptr)
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i]));
+                    PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i]));
+                  }
+              }
+          }
+        PORT_WRITE(out_READ_UNIT_OUT_ACK [i], ack);
+      }
+                      if (_param->_have_port_context_id)
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_CONTEXT_ID            [dest][port], PORT_READ(in_READ_UNIT_OUT_CONTEXT_ID            [i][j]));
+                      if (_param->_have_port_front_end_id)
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_FRONT_END_ID          [dest][port], PORT_READ(in_READ_UNIT_OUT_FRONT_END_ID          [i][j]));
+                      if (_param->_have_port_ooo_engine_id)
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_OOO_ENGINE_ID         [dest][port], PORT_READ(in_READ_UNIT_OUT_OOO_ENGINE_ID         [i][j]));
+                      if (_param->_have_port_rob_ptr  )
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_PACKET_ID             [dest][port], PORT_READ(in_READ_UNIT_OUT_PACKET_ID             [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_OPERATION             [dest][port], PORT_READ(in_READ_UNIT_OUT_OPERATION             [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_TYPE                  [dest][port], PORT_READ(in_READ_UNIT_OUT_TYPE                  [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_HAS_IMMEDIAT          [dest][port], PORT_READ(in_READ_UNIT_OUT_HAS_IMMEDIAT          [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RC               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RC               [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RD              [dest][port], PORT_READ(in_READ_UNIT_OUT_WRITE_RD              [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_WRITE_RE              [dest][port], PORT_READ(in_READ_UNIT_OUT_WRITE_RE              [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RE            [dest][port], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RE            [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_STORE_QUEUE_PTR_WRITE [dest][port], PORT_READ(in_READ_UNIT_OUT_STORE_QUEUE_PTR_WRITE [i][j]));
+                      if (_param->_have_port_load_queue_ptr)
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_LOAD_QUEUE_PTR_WRITE  [dest][port], PORT_READ(in_READ_UNIT_OUT_LOAD_QUEUE_PTR_WRITE  [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_IMMEDIAT              [dest][port], PORT_READ(in_READ_UNIT_OUT_IMMEDIAT              [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RA               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RA               [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_DATA_RB               [dest][port], PORT_READ(in_READ_UNIT_OUT_DATA_RB               [i][j]));
+                      PORT_WRITE(out_EXECUTE_UNIT_IN_NUM_REG_RD            [dest][port], PORT_READ(in_READ_UNIT_OUT_NUM_REG_RD            [i][j]));
+                    }
+                }
+            }
+          PORT_WRITE(out_READ_UNIT_OUT_ACK [i][j], ack);
+        }
     for (uint32_t i=0; i<_param->_nb_execute_unit; i++)
+      {
+        PORT_WRITE(out_EXECUTE_UNIT_IN_VAL[i], execute_unit_use[i]);
+      }
+      for (uint32_t j=0; j<_param->_nb_execute_unit_port[i]; j++)
+        PORT_WRITE(out_EXECUTE_UNIT_IN_VAL[i][j], execute_unit_use[i][j]);
     log_printf(FUNC,Read_unit_to_Execution_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit/src/Read_unit_to_Execution_unit_transition.cpp

-              r81
+              r88
         // Fill routing table
         for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_execute_unit; j++)
+            // Test if link between src and dest
+            if (_param->_table_routing [i][j])
+              // Test the thread accepted by the execute_unit
+              for (uint32_t k=0; k<_param->_nb_thread; k++)
+                if (_param->_table_execute_thread[j][k])
+                  // Test the type accepted by the execute_unit
+                  for (uint32_t l=0; l<_param->_nb_type; l++)
+                    if (_param->_table_execute_type [j][l])
+                      // push_back == minor have a better priority
+                      _destination [i][k][l].push_back(j);
+          for (uint32_t x=0; x<_param->_nb_execute_unit; x++)
+            for (uint32_t y=0; y<_param->_nb_execute_unit_port[x]; y++)
+              // Test if link between src and dest
+              if (_param->_table_routing [i][x][y])
+                // Test the thread accepted by the execute_unit
+                for (uint32_t k=0; k<_param->_nb_thread; k++)
+                  if (_param->_table_execute_thread[x][k])
+                    // Test the type accepted by the execute_unit
+                    for (uint32_t l=0; l<_param->_nb_type; l++)
+                      if (_param->_table_execute_type [x][l])
+                        // push_back == minor have a better priority
+                        _destination [i][k][l].push_back(destination_t(x,y));
+      }
     else

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/Makefile

r81	r88
24	24	library_clean : Register_unit_Glue_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/include/test.h

-              r81
+              r88
 #include <sys/time.h>
+#include "Common/include/Time.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
 …
 void test    (string name,
               morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters * param);
-class Time
+{
-private : timeval time_begin;
-// private : timeval time_end;
-public  : Time ()
+  {
-    gettimeofday(&time_begin     ,NULL);
-  };
-public  : ~Time ()
+  {
-    cout << *this;
-  };
-public  : friend ostream& operator<< (ostream& output_stream,
-                                      const Time & x)
+  {
-    timeval time_end;
-    gettimeofday(&time_end       ,NULL);
-    uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
-    double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec);
-    output_stream << nb_cycles << "\t(" << average << " cycles / seconds )" << endl;
-    return output_stream;
+  }
-};

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_spr_write     ,
          _nb_inst_insert_rob,
+         _nb_inst_retire_rob);
+         _nb_inst_retire_rob,
+         true //is_toplevel
+         );
       cout << param->print(1);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Register_unit_Glue * _Register_unit_Glue = new Register_unit_Glue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_SPR_STATUS_ACK            ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL                       ;
   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK                       ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE                ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE                ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE                ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE                ;
   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL                       ;
+//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK                       ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE                ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE                ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE                ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE                ;
+//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
+//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
+//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
+//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
   string rename;
 …
+      }
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     in_RETIRE_ROB_VAL                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_ACK                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RD_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RD_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RE_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RE_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+      {
         uint32_t x=_param->_nb_inst_retire_rob [i];
          in_RETIRE_ROB_VAL                      [i] = new sc_signal<Tcontrol_t> * [x];
         out_RETIRE_ROB_ACK                      [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_RD_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_RD_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_RE_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_RE_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
         out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
         out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
         out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
         out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
          in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     in_RETIRE_ROB_VAL                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_ACK                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
+//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//       {
+//      uint32_t x=_param->_nb_inst_retire_rob [i];
+//       in_RETIRE_ROB_VAL                      [i] = new sc_signal<Tcontrol_t> * [x];
+//      out_RETIRE_ROB_ACK                      [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_RD_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_RD_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_RE_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_RE_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
+//      out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
+//      out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
+//      out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
+//      out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
+//       in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
         for (uint32_t j=0; j<x; j++)
+          {
                in_RETIRE_ROB_VAL                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
               out_RETIRE_ROB_ACK                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_RD_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_RD_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_RE_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_RE_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
               out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
               out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
               out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
               out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
                in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+            }
+      }
+//      for (uint32_t j=0; j<x; j++)
+//        {
+//             in_RETIRE_ROB_VAL                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//            out_RETIRE_ROB_ACK                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_RD_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_RD_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_RE_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_RE_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//            out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//            out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//            out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//            out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//             in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
+//          }
+//       }
 …
+      }
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+      {
         uint32_t x=_param->_nb_inst_retire_rob [i];
         for (uint32_t j=0; j<x; j++)
+          {
             (*(_Register_unit_Glue-> in_RETIRE_ROB_VAL                [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
             (*(_Register_unit_Glue->out_RETIRE_ROB_ACK                [i][j]))(*(out_RETIRE_ROB_ACK                [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
             (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
             (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
             (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
             (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]));
             (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
+            }
+      }
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//       {
+//      uint32_t x=_param->_nb_inst_retire_rob [i];
+//      for (uint32_t j=0; j<x; j++)
+//        {
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_VAL                [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
+//          (*(_Register_unit_Glue->out_RETIRE_ROB_ACK                [i][j]))(*(out_RETIRE_ROB_ACK                [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
+//          (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
+//          (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
+//          (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
+//          (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]));
+//          (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
+//          }
+//       }
   cout << "<" << name << "> Start Simulation ............" << endl;
 …
   const bool     test_write  = true;
   const bool     test_insert = true;
   const bool     test_retire = true;
+//   const bool     test_retire = true;
   const  int32_t percent_transaction = 75;
 …
   Tcontrol_t      spr_write_status_val       [_param->_nb_ooo_engine][_param->_nb_spr_write];
   uint32_t        max_nb_inst_retire_rob = 0;
   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     if (_param->_nb_inst_retire_rob [i] > max_nb_inst_retire_rob)
       max_nb_inst_retire_rob = _param->_nb_inst_retire_rob [i];
   Tcontrol_t      retire_rob_ack                [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
   Tcontrol_t      retire_rob_gpr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
   Tcontrol_t      retire_rob_gpr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
   Tcontrol_t      retire_rob_spr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
   Tcontrol_t      retire_rob_spr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
+//   uint32_t        max_nb_inst_retire_rob = 0;
+//   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//     if (_param->_nb_inst_retire_rob [i] > max_nb_inst_retire_rob)
+//       max_nb_inst_retire_rob = _param->_nb_inst_retire_rob [i];
+//   Tcontrol_t      retire_rob_ack                [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
+//   Tcontrol_t      retire_rob_gpr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
+//   Tcontrol_t      retire_rob_gpr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
+//   Tcontrol_t      retire_rob_spr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
+//   Tcontrol_t      retire_rob_spr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
   uint32_t        max_nb_inst_insert_rob = 0;
 …
+        }
       if (test_retire == true)
+        {
           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+            {
               uint32_t x = _param->_nb_inst_retire_rob [i];
               for (uint32_t j=0; j<x; j++)
+                {
                 Tcontrol_t val                = (rand()%100)<=percent_transaction;
                 Tcontrol_t rd_old_use         = (rand()%100)<=percent_transaction;
                 Tcontrol_t rd_new_use         = (rand()%100)<=percent_transaction;
                 Tcontrol_t re_old_use         = (rand()%100)<=percent_transaction;
                 Tcontrol_t re_new_use         = (rand()%100)<=percent_transaction;
                 Tcontrol_t gpr_status_old_ack = (rand()%100)<=percent_transaction;
                 Tcontrol_t gpr_status_new_ack = (rand()%100)<=percent_transaction;
                 Tcontrol_t spr_status_old_ack = (rand()%100)<=percent_transaction;
                 Tcontrol_t spr_status_new_ack = (rand()%100)<=percent_transaction;
                 in_RETIRE_ROB_VAL                [i][j]->write(val               );
                 in_RETIRE_ROB_RD_OLD_USE         [i][j]->write(rd_old_use        );
                 in_RETIRE_ROB_RD_NEW_USE         [i][j]->write(rd_new_use        );
                 in_RETIRE_ROB_RE_OLD_USE         [i][j]->write(re_old_use        );
                 in_RETIRE_ROB_RE_NEW_USE         [i][j]->write(re_new_use        );
                 in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]->write(gpr_status_old_ack);
                 in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]->write(gpr_status_new_ack);
                 in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]->write(spr_status_old_ack);
                 in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]->write(spr_status_new_ack);
+//       if (test_retire == true)
+//      {
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          {
+//            uint32_t x = _param->_nb_inst_retire_rob [i];
+//            for (uint32_t j=0; j<x; j++)
+//              {
+//              Tcontrol_t val                = (rand()%100)<=percent_transaction;
+//              Tcontrol_t rd_old_use         = (rand()%100)<=percent_transaction;
+//              Tcontrol_t rd_new_use         = (rand()%100)<=percent_transaction;
+//              Tcontrol_t re_old_use         = (rand()%100)<=percent_transaction;
+//              Tcontrol_t re_new_use         = (rand()%100)<=percent_transaction;
+//              Tcontrol_t gpr_status_old_ack = (rand()%100)<=percent_transaction;
+//              Tcontrol_t gpr_status_new_ack = (rand()%100)<=percent_transaction;
+//              Tcontrol_t spr_status_old_ack = (rand()%100)<=percent_transaction;
+//              Tcontrol_t spr_status_new_ack = (rand()%100)<=percent_transaction;
+//              in_RETIRE_ROB_VAL                [i][j]->write(val               );
+//              in_RETIRE_ROB_RD_OLD_USE         [i][j]->write(rd_old_use        );
+//              in_RETIRE_ROB_RD_NEW_USE         [i][j]->write(rd_new_use        );
+//              in_RETIRE_ROB_RE_OLD_USE         [i][j]->write(re_old_use        );
+//              in_RETIRE_ROB_RE_NEW_USE         [i][j]->write(re_new_use        );
+//              in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]->write(gpr_status_old_ack);
+//              in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]->write(gpr_status_new_ack);
+//              in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]->write(spr_status_old_ack);
+//              in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]->write(spr_status_new_ack);
                 retire_rob_ack                [i][j] = (gpr_status_new_ack and
                                                         gpr_status_old_ack and
                                                         spr_status_new_ack and
                                                         spr_status_old_ack);
                 retire_rob_gpr_status_old_val [i][j] = val and rd_old_use                        and gpr_status_new_ack and spr_status_old_ack and spr_status_new_ack;
                 retire_rob_gpr_status_new_val [i][j] = val and rd_new_use and gpr_status_old_ack                        and spr_status_old_ack and spr_status_new_ack;
                 retire_rob_spr_status_old_val [i][j] = val and re_old_use and gpr_status_old_ack and gpr_status_new_ack                        and spr_status_new_ack;
                 retire_rob_spr_status_new_val [i][j] = val and re_new_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_old_ack                       ;
+                }
+            }
+        }
+//              retire_rob_ack                [i][j] = (gpr_status_new_ack and
+//                                                      gpr_status_old_ack and
+//                                                      spr_status_new_ack and
+//                                                      spr_status_old_ack);
+//              retire_rob_gpr_status_old_val [i][j] = val and rd_old_use                        and gpr_status_new_ack and spr_status_old_ack and spr_status_new_ack;
+//              retire_rob_gpr_status_new_val [i][j] = val and rd_new_use and gpr_status_old_ack                        and spr_status_old_ack and spr_status_new_ack;
+//              retire_rob_spr_status_old_val [i][j] = val and re_old_use and gpr_status_old_ack and gpr_status_new_ack                        and spr_status_new_ack;
+//              retire_rob_spr_status_new_val [i][j] = val and re_new_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_old_ack                       ;
+//              }
+//          }
+//      }
       if (test_insert == true)
 …
       if (test_retire == true)
+        {
           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+            {
               uint32_t x = _param->_nb_inst_retire_rob [i];
               for (uint32_t j=0; j<x; j++)
+                {
                   TEST(Tcontrol_t, out_RETIRE_ROB_ACK                [i][j]->read(), retire_rob_ack                [i][j]);
                   TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_gpr_status_old_val [i][j]);
                   TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_gpr_status_new_val [i][j]);
                   TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_spr_status_old_val [i][j]);
                   TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_spr_status_new_val [i][j]);
+                }
+            }
+        }
+//       if (test_retire == true)
+//      {
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          {
+//            uint32_t x = _param->_nb_inst_retire_rob [i];
+//            for (uint32_t j=0; j<x; j++)
+//              {
+//                TEST(Tcontrol_t, out_RETIRE_ROB_ACK                [i][j]->read(), retire_rob_ack                [i][j]);
+//                TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_gpr_status_old_val [i][j]);
+//                TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_gpr_status_new_val [i][j]);
+//                TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_spr_status_old_val [i][j]);
+//                TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_spr_status_new_val [i][j]);
+//              }
+//          }
+//      }
       if (test_insert == true)
 …
   delete [] out_INSERT_ROB_SPR_STATUS_VAL       ;
   delete []  in_INSERT_ROB_SPR_STATUS_ACK       ;
   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       ;
+//   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       ;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Parameters.h

-              r81
+              r88
   class Parameters : public morpheo::behavioural::Parameters
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t    _nb_ooo_engine        ;
   public : const uint32_t    _size_general_data    ;
   public : const uint32_t    _size_special_data    ;
   public : const uint32_t    _nb_gpr_read          ;
   public : const uint32_t    _nb_spr_read          ;
   public : const uint32_t    _nb_gpr_write         ;
   public : const uint32_t    _nb_spr_write         ;
   public : const uint32_t  * _nb_inst_insert_rob   ;
   public : const uint32_t  * _nb_inst_retire_rob   ;
+  public : uint32_t    _nb_ooo_engine        ;
+//public : uint32_t    _size_general_data    ;
+//public : uint32_t    _size_special_data    ;
+  public : uint32_t    _nb_gpr_read          ;
+  public : uint32_t    _nb_spr_read          ;
+  public : uint32_t    _nb_gpr_write         ;
+  public : uint32_t    _nb_spr_write         ;
+  public : uint32_t  * _nb_inst_insert_rob   ;
+  public : uint32_t  * _nb_inst_retire_rob   ;
   public : const bool        _have_port_ooo_engine_id;
+//public : bool        _have_port_ooo_engine_id;
     //-----[ methods ]-----------------------------------------------------------
+  public : Parameters  (const uint32_t   nb_ooo_engine        ,
+                        const uint32_t   size_general_data    ,
+                        const uint32_t   size_special_data    ,
+                        const uint32_t   nb_gpr_read          ,
+                        const uint32_t   nb_spr_read          ,
+                        const uint32_t   nb_gpr_write         ,
+                        const uint32_t   nb_spr_write         ,
+                        const uint32_t * nb_inst_insert_rob   ,
+                        const uint32_t * nb_inst_retire_rob   );
+  public : Parameters  (Parameters & param) ;
+  public : Parameters  (uint32_t   nb_ooo_engine        ,
+                        uint32_t   size_general_data    ,
+                        uint32_t   size_special_data    ,
+                        uint32_t   nb_gpr_read          ,
+                        uint32_t   nb_spr_read          ,
+                        uint32_t   nb_gpr_write         ,
+                        uint32_t   nb_spr_write         ,
+                        uint32_t * nb_inst_insert_rob   ,
+                        uint32_t * nb_inst_retire_rob   ,
+                        bool       is_toplevel=false);
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h

-              r82
+              r88
   public    : SC_IN (Tcontrol_t        )  ***  in_INSERT_ROB_SPR_STATUS_ACK            ;
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL                       ;
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK                       ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE                ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE                ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE                ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE                ;
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL                       ;
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK                       ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE                ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE                ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE                ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE                ;
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Parameters.cpp

-              r81
+              r88
 #undef  FUNCTION
 #define FUNCTION "Register_unit_Glue::Parameters"
+  Parameters::Parameters (const uint32_t   nb_ooo_engine        ,
+                          const uint32_t   size_general_data    ,
+                          const uint32_t   size_special_data    ,
+                          const uint32_t   nb_gpr_read          ,
+                          const uint32_t   nb_spr_read          ,
+                          const uint32_t   nb_gpr_write         ,
+                          const uint32_t   nb_spr_write         ,
+                          const uint32_t * nb_inst_insert_rob   ,
+                          const uint32_t * nb_inst_retire_rob   ):
+    _nb_ooo_engine        (nb_ooo_engine    ),
+    _size_general_data    (size_general_data),
+    _size_special_data    (size_special_data),
+    _nb_gpr_read          (nb_gpr_read      ),
+    _nb_spr_read          (nb_spr_read      ),
+    _nb_gpr_write         (nb_gpr_write     ),
+    _nb_spr_write         (nb_spr_write     ),
+    _nb_inst_insert_rob   (nb_inst_insert_rob),
+    _nb_inst_retire_rob   (nb_inst_retire_rob),
+    _have_port_ooo_engine_id (nb_ooo_engine>1)
+  Parameters::Parameters (uint32_t   nb_ooo_engine        ,
+                          uint32_t   size_general_data    ,
+                          uint32_t   size_special_data    ,
+                          uint32_t   nb_gpr_read          ,
+                          uint32_t   nb_spr_read          ,
+                          uint32_t   nb_gpr_write         ,
+                          uint32_t   nb_spr_write         ,
+                          uint32_t * nb_inst_insert_rob   ,
+                          uint32_t * nb_inst_retire_rob   ,
+                          bool       is_toplevel          )
+  {
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    _nb_ooo_engine           = nb_ooo_engine     ;
+    _nb_gpr_read             = nb_gpr_read       ;
+    _nb_spr_read             = nb_spr_read       ;
+    _nb_gpr_write            = nb_gpr_write      ;
+    _nb_spr_write            = nb_spr_write      ;
+    _nb_inst_insert_rob      = nb_inst_insert_rob;
+    _nb_inst_retire_rob      = nb_inst_retire_rob;
     test();
+    if (is_toplevel)
+      {
+        _size_ooo_engine_id      = log2(nb_ooo_engine);
+        _size_general_data       = size_general_data ;
+        _size_special_data       = size_special_data ;
+        _have_port_ooo_engine_id = _size_ooo_engine_id > 0;
+        copy();
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Register_unit_Glue::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _nb_ooo_engine        (param._nb_ooo_engine    ),
+//     _size_general_data    (param._size_general_data),
+//     _size_special_data    (param._size_special_data),
+//     _nb_gpr_read          (param._nb_gpr_read      ),
+//     _nb_spr_read          (param._nb_spr_read      ),
+//     _nb_gpr_write         (param._nb_gpr_write     ),
+//     _nb_spr_write         (param._nb_spr_write     ),
+//     _nb_inst_insert_rob   (param._nb_inst_insert_rob),
+//     _nb_inst_retire_rob   (param._nb_inst_retire_rob),
+//     _have_port_ooo_engine_id (param._have_port_ooo_engine_id)
+//   {
+//     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Register_unit_Glue::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _nb_ooo_engine        (param._nb_ooo_engine    ),
+    _size_general_data    (param._size_general_data),
+    _size_special_data    (param._size_special_data),
+    _nb_gpr_read          (param._nb_gpr_read      ),
+    _nb_spr_read          (param._nb_spr_read      ),
+    _nb_gpr_write         (param._nb_gpr_write     ),
+    _nb_spr_write         (param._nb_spr_write     ),
+    _nb_inst_insert_rob   (param._nb_inst_insert_rob),
+    _nb_inst_retire_rob   (param._nb_inst_retire_rob),
+    _have_port_ooo_engine_id (param._have_port_ooo_engine_id)
+#define FUNCTION "Register_unit_Glue::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
-    test();
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Register_unit_Glue::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Register_unit_Glue::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue.cpp

-              r81
+              r88
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+#if DEBUG_Register_unit_Glue == true
+    log_printf(INFO,Register_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Register_unit_Glue,FUNCTION,"Allocation");
     allocation ();
 #ifdef STATISTICS
+    log_printf(INFO,Register_unit_Glue,FUNCTION,"Allocation of statistics");
+    // Allocation of statistics
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Register_unit_Glue,FUNCTION,"Allocation of statistics");
+        // Allocation of statistics
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate the vhdl");
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate the vhdl");
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // Constant
 …
 #endif
     log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_retire");
     SC_METHOD (genMealy_retire);
     dont_initialize ();
 //     sensitive_neg << *(in_CLOCK);
     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+      {
         uint32_t x=_param->_nb_inst_retire_rob [i];
         for (uint32_t j=0; j<x; j++)
           sensitive << *( in_RETIRE_ROB_VAL                [i][j])
                     << *( in_RETIRE_ROB_RD_OLD_USE         [i][j])
                     << *( in_RETIRE_ROB_RD_NEW_USE         [i][j])
                     << *( in_RETIRE_ROB_RE_OLD_USE         [i][j])
                     << *( in_RETIRE_ROB_RE_NEW_USE         [i][j])
                     << *( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j])
                     << *( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j])
                     << *( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j])
                     << *( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]);
+      }
 #ifdef SYSTEMCASS_SPECIFIC
     // List dependency information
     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+      {
         uint32_t x=_param->_nb_inst_retire_rob [i];
         for (uint32_t j=0; j<x; j++)
+          {
             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
             (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
+          }
+      }
 #endif
+//     log_printf(INFO,Register_unit_Glue,FUNCTION,"Method - genMealy_retire");
+//     SC_METHOD (genMealy_retire);
+//     dont_initialize ();
+// //     sensitive_neg << *(in_CLOCK);
+//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//       {
+//      uint32_t x=_param->_nb_inst_retire_rob [i];
+//      for (uint32_t j=0; j<x; j++)
+//        sensitive << *( in_RETIRE_ROB_VAL                [i][j])
+//                  << *( in_RETIRE_ROB_RD_OLD_USE         [i][j])
+//                  << *( in_RETIRE_ROB_RD_NEW_USE         [i][j])
+//                  << *( in_RETIRE_ROB_RE_OLD_USE         [i][j])
+//                  << *( in_RETIRE_ROB_RE_NEW_USE         [i][j])
+//                  << *( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j])
+//                  << *( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j])
+//                  << *( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j])
+//                  << *( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]);
+//       }
+// #ifdef SYSTEMCASS_SPECIFIC
+//     // List dependency information
+//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//       {
+//      uint32_t x=_param->_nb_inst_retire_rob [i];
+//      for (uint32_t j=0; j<x; j++)
+//        {
+//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_ACK                [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
+//          (*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
+//        }
+//       }
+// #endif
+      }
 #endif
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate Statistics file");
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Register_unit_Glue,FUNCTION,"Generate Statistics file");
+        delete _stat;
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_allocation.cpp

-              r82
+              r88
        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", log2(_param->_nb_ooo_engine));
+        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);
 …
        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", log2(_param->_nb_ooo_engine));
+        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);
 …
        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", log2(_param->_nb_ooo_engine));
+        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++)
 …
        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", log2(_param->_nb_ooo_engine));
+        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 "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     in_RETIRE_ROB_VAL                      = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_ACK                      = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RD_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RD_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RE_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_RE_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
     in_RETIRE_ROB_SPR_STATUS_NEW_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_retire_rob [i];
          in_RETIRE_ROB_VAL                      [i] = new SC_IN (Tcontrol_t) * [x];
         out_RETIRE_ROB_ACK                      [i] = new SC_OUT(Tcontrol_t) * [x];
          in_RETIRE_ROB_RD_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
          in_RETIRE_ROB_RD_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
          in_RETIRE_ROB_RE_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
          in_RETIRE_ROB_RE_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
         out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
         out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
          in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
          in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
         out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
         out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
          in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
          in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     in_RETIRE_ROB_VAL                      = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_ACK                      = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_OLD_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_NEW_USE               = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
+//    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_SPR_STATUS_NEW_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_retire_rob [i];
+//       in_RETIRE_ROB_VAL                      [i] = new SC_IN (Tcontrol_t) * [x];
+//      out_RETIRE_ROB_ACK                      [i] = new SC_OUT(Tcontrol_t) * [x];
+//       in_RETIRE_ROB_RD_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
+//       in_RETIRE_ROB_RD_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
+//       in_RETIRE_ROB_RE_OLD_USE               [i] = new SC_IN (Tcontrol_t) * [x];
+//       in_RETIRE_ROB_RE_NEW_USE               [i] = new SC_IN (Tcontrol_t) * [x];
+//      out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
+//      out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
+//       in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
+//       in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
+//      out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
+//      out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new SC_OUT(Tcontrol_t) * [x];
+//       in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
+//       in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new SC_IN (Tcontrol_t) * [x];
         for (uint32_t j=0; j<x; j++)
+          {
+            {
               Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
 #ifdef POSITION
                                                                       ,IN
                                                                       ,WEST
                                                                       ,"Interface to update status (retire)"
 #endif
                                                                       );
                in_RETIRE_ROB_VAL                      [i][j] = interface->set_signal_valack_in (VAL);
               out_RETIRE_ROB_ACK                      [i][j] = interface->set_signal_valack_out(ACK);
                in_RETIRE_ROB_RD_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_old_use", 1);
                in_RETIRE_ROB_RD_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_new_use", 1);
                in_RETIRE_ROB_RE_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_old_use", 1);
                in_RETIRE_ROB_RE_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_new_use", 1);
+            }
+            {
               Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_old_"+toString(i)+"_"+toString(j)
 #ifdef POSITION
                                                                       ,IN
                                                                       ,EAST
                                                                       ,"Interface to update status (retire)"
 #endif
                                                                       );
               out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
                in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
+            }
+            {
               Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_new_"+toString(i)+"_"+toString(j)
 #ifdef POSITION
                                                                       ,IN
                                                                       ,EAST
                                                                       ,"Interface to update status (retire)"
 #endif
                                                                       );
               out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
                in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
+            }
+            {
               Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_old_"+toString(i)+"_"+toString(j)
 #ifdef POSITION
                                                                       ,IN
                                                                       ,EAST
                                                                       ,"Interface to update status (retire)"
 #endif
                                                                       );
               out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
                in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
+            }
+            {
               Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_new_"+toString(i)+"_"+toString(j)
 #ifdef POSITION
                                                                       ,IN
                                                                       ,EAST
                                                                       ,"Interface to update status (retire)"
 #endif
                                                                       );
               out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
                in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
+            }
+          }
+      }
+//      for (uint32_t j=0; j<x; j++)
+//        {
+//          {
+//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
+// #ifdef POSITION
+//                                                                    ,IN
+//                                                                    ,WEST
+//                                                                    ,"Interface to update status (retire)"
+// #endif
+//                                                                    );
+//             in_RETIRE_ROB_VAL                      [i][j] = interface->set_signal_valack_in (VAL);
+//            out_RETIRE_ROB_ACK                      [i][j] = interface->set_signal_valack_out(ACK);
+//             in_RETIRE_ROB_RD_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_old_use", 1);
+//             in_RETIRE_ROB_RD_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_new_use", 1);
+//             in_RETIRE_ROB_RE_OLD_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_old_use", 1);
+//             in_RETIRE_ROB_RE_NEW_USE               [i][j] = interface->set_signal_in <Tcontrol_t> ("re_new_use", 1);
+//          }
+//          {
+//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_old_"+toString(i)+"_"+toString(j)
+// #ifdef POSITION
+//                                                                    ,IN
+//                                                                    ,EAST
+//                                                                    ,"Interface to update status (retire)"
+// #endif
+//                                                                    );
+//            out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
+//             in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
+//          }
+//          {
+//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_new_"+toString(i)+"_"+toString(j)
+// #ifdef POSITION
+//                                                                    ,IN
+//                                                                    ,EAST
+//                                                                    ,"Interface to update status (retire)"
+// #endif
+//                                                                    );
+//            out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
+//             in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
+//          }
+//          {
+//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_old_"+toString(i)+"_"+toString(j)
+// #ifdef POSITION
+//                                                                    ,IN
+//                                                                    ,EAST
+//                                                                    ,"Interface to update status (retire)"
+// #endif
+//                                                                    );
+//            out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
+//             in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
+//          }
+//          {
+//            Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_new_"+toString(i)+"_"+toString(j)
+// #ifdef POSITION
+//                                                                    ,IN
+//                                                                    ,EAST
+//                                                                    ,"Interface to update status (retire)"
+// #endif
+//                                                                    );
+//            out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
+//             in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
+//          }
+//        }
+//       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    if (usage_is_set(_usage,USE_VHDL))
+      {
 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     delete    in_CLOCK ;
 …
     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       ;
+//     // ~~~~~[ 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       ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_gpr_read (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+//        PORT_WRITE(out_GPR_READ_ACK      [j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+        // multiplexor
+        PORT_WRITE(out_GPR_READ_ACK      [j], registerfile_ack and status_ack);
+        PORT_WRITE(out_GPR_READ_DATA     [j], PORT_READ(in_GPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
+        PORT_WRITE(out_GPR_READ_DATA_VAL [j], PORT_READ(in_GPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
+        for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+          {
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+            // multiplexor
+            PORT_WRITE(out_GPR_READ_ACK      [j], registerfile_ack and status_ack);
+            PORT_WRITE(out_GPR_READ_DATA     [j], PORT_READ(in_GPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
+            PORT_WRITE(out_GPR_READ_DATA_VAL [j], PORT_READ(in_GPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read_registerfile.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_gpr_read_registerfile (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j],0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
+        Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+        Tcontrol_t registerfile_val = val and status_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
+            Tcontrol_t status_ack       = PORT_READ(in_GPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+            Tcontrol_t registerfile_val = val and status_ack;
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_GPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_read_status.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_gpr_read_status (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
+        Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_val       = val and registerfile_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], (id and status_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_READ_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_GPR_READ_VAL [j]);
+            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_val       = val and registerfile_ack;
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_GPR_READ_STATUS_VAL       [i][j], (id and status_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_registerfile.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_gpr_write_registerfile (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
+        Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+        Tcontrol_t registerfile_val = val and status_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
+            Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+            Tcontrol_t registerfile_val = val and status_ack;
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_GPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_write.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_gpr_write (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_GPR_WRITE_ACK [j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+        // multiplexor
+        PORT_WRITE(out_GPR_WRITE_ACK [j],registerfile_ack and status_ack);
+        for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+          {
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_ack       = PORT_READ(in_GPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+            // multiplexor
+            PORT_WRITE(out_GPR_WRITE_ACK [j],registerfile_ack and status_ack);
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_gpr_write_status.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_gpr_write_status (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
+        Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_val       = val and registerfile_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_GPR_WRITE_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_GPR_WRITE_VAL [j]);
+            Tcontrol_t registerfile_ack = PORT_READ(in_GPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_val       = val and registerfile_ack;
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_GPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_insert.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_insert (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+      {
+        uint32_t x=_param->_nb_inst_insert_rob [i];
+      for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
+        {
+          Tcontrol_t val            = PORT_READ(in_INSERT_ROB_VAL [i][j]);
+          Tcontrol_t gpr_use        = PORT_READ(in_INSERT_ROB_RD_USE [i][j]);
+          Tcontrol_t spr_use        = PORT_READ(in_INSERT_ROB_RE_USE [i][j]);
+          Tcontrol_t gpr_status_ack = PORT_READ(in_INSERT_ROB_GPR_STATUS_ACK [i][j]);
+          Tcontrol_t spr_status_ack = PORT_READ(in_INSERT_ROB_SPR_STATUS_ACK [i][j]);
+          Tcontrol_t ack            = (gpr_status_ack and
+                                       spr_status_ack);
+          Tcontrol_t gpr_status_val = (val     and
+                                       gpr_use and
+                                       spr_status_ack);
+          Tcontrol_t spr_status_val = (val     and
+                                       spr_use and
+                                       gpr_status_ack);
+        for (uint32_t j=0; j<x; j++)
+          {
+            Tcontrol_t val = PORT_READ(in_INSERT_ROB_VAL [i][j]);
+            Tcontrol_t gpr_use = PORT_READ(in_INSERT_ROB_RD_USE [i][j]);
+            Tcontrol_t spr_use = PORT_READ(in_INSERT_ROB_RE_USE [i][j]);
+            Tcontrol_t gpr_ack = PORT_READ(in_INSERT_ROB_GPR_STATUS_ACK [i][j]);
+            Tcontrol_t spr_ack = PORT_READ(in_INSERT_ROB_SPR_STATUS_ACK [i][j]);
+            PORT_WRITE(out_INSERT_ROB_ACK [i][j], gpr_ack and spr_ack);
+            PORT_WRITE(out_INSERT_ROB_GPR_STATUS_VAL [i][j], val and gpr_use and spr_ack);
+            PORT_WRITE(out_INSERT_ROB_SPR_STATUS_VAL [i][j], val and spr_use and gpr_ack);
+          }
+      }
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"  * insert_rob [%d][%d]",i,j);
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * val            (r) : %d",val           );
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * ack            (w) : %d",ack           );
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * gpr_use (rd)   (r) : %d",gpr_use       );
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * gpr_status_val (w) : %d",gpr_status_val);
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * gpr_status_ack (r) : %d",gpr_status_ack);
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * spr_use (re)   (r) : %d",spr_use       );
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * spr_status_val (w) : %d",spr_status_val);
+          log_printf(TRACE,OOO_Engine_Glue,FUNCTION,"    * spr_status_ack (r) : %d",spr_status_ack);
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+          PORT_WRITE(out_INSERT_ROB_ACK            [i][j], ack           );
+          PORT_WRITE(out_INSERT_ROB_GPR_STATUS_VAL [i][j], gpr_status_val);
+          PORT_WRITE(out_INSERT_ROB_SPR_STATUS_VAL [i][j], spr_status_val);
+        }
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_retire.cpp

-              r81
+              r88
  */
+/*
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
 …
   void Register_unit_Glue::genMealy_retire (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
 …
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
+*/
 #endif
 //#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_spr_read (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+//        PORT_WRITE(out_SPR_READ_ACK      [j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+        // multiplexor
+        PORT_WRITE(out_SPR_READ_ACK      [j], registerfile_ack and status_ack);
+        PORT_WRITE(out_SPR_READ_DATA     [j], PORT_READ(in_SPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
+        PORT_WRITE(out_SPR_READ_DATA_VAL [j], PORT_READ(in_SPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
+        for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+          {
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+            // multiplexor
+            PORT_WRITE(out_SPR_READ_ACK      [j], registerfile_ack and status_ack);
+            PORT_WRITE(out_SPR_READ_DATA     [j], PORT_READ(in_SPR_READ_REGISTERFILE_DATA[ooo_engine_id][j]));
+            PORT_WRITE(out_SPR_READ_DATA_VAL [j], PORT_READ(in_SPR_READ_STATUS_DATA_VAL  [ooo_engine_id][j]));
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read_registerfile.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_spr_read_registerfile (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL [i][j],0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
+        Tcontrol_t status_ack       = PORT_READ(in_SPR_READ_STATUS_ACK       [ooo_engine_id][j]);
+        Tcontrol_t registerfile_val = val and status_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
+            Tcontrol_t registerfile_val = val and PORT_READ(in_SPR_READ_STATUS_ACK [ooo_engine_id][j]);
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_SPR_READ_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_read_status.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_spr_read_status (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_SPR_READ_STATUS_VAL       [i][j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
+        Tcontrol_t registerfile_ack = PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_val       = val and registerfile_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_spr_read; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_SPR_READ_STATUS_VAL       [i][j], (id and status_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_READ_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_SPR_READ_VAL [j]);
+            Tcontrol_t status_val       = val and PORT_READ(in_SPR_READ_REGISTERFILE_ACK [ooo_engine_id][j]);
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_SPR_READ_STATUS_VAL       [i][j], (id and status_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_registerfile.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_spr_write_registerfile (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL [i][j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
+        Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+        Tcontrol_t registerfile_val = val and status_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
+            Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+            Tcontrol_t registerfile_val = val and status_ack;
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_SPR_WRITE_REGISTERFILE_VAL [i][j], (id and registerfile_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_write.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_spr_write (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_SPR_WRITE_ACK [j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+        // multiplexor
+        PORT_WRITE(out_SPR_WRITE_ACK [j],registerfile_ack and status_ack);
+        for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+          {
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_ack       = PORT_READ(in_SPR_WRITE_STATUS_ACK       [ooo_engine_id][j]);
+            // multiplexor
+            PORT_WRITE(out_SPR_WRITE_ACK [j],registerfile_ack and status_ack);
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_genMealy_spr_write_status.cpp

-              r81
+              r88
   void Register_unit_Glue::genMealy_spr_write_status (void)
+  {
+    log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
+    log_function(Register_unit_Glue,FUNCTION,_name.c_str());
+    for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+//     if (not PORT_READ(in_NRESET))
+//       {
+//      for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          PORT_WRITE(out_SPR_WRITE_STATUS_VAL       [i][j], 0);
+//       }
+//     else
+      {
+        Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
+        Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
+        Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+        Tcontrol_t status_val       = val and registerfile_ack;
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        for (uint32_t j=0; j<_param->_nb_spr_write; j++)
+          {
+            Tcontrol_t id = (i == ooo_engine_id)?1:0;
+            PORT_WRITE(out_SPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
+            Tcontext_t ooo_engine_id    = (_param->_have_port_ooo_engine_id == true)?PORT_READ(in_SPR_WRITE_OOO_ENGINE_ID[j]):0;
+            Tcontrol_t val              = PORT_READ(in_SPR_WRITE_VAL [j]);
+            Tcontrol_t registerfile_ack = PORT_READ(in_SPR_WRITE_REGISTERFILE_ACK [ooo_engine_id][j]);
+            Tcontrol_t status_val       = val and registerfile_ack;
+            for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+              {
+                Tcontrol_t id = (i == ooo_engine_id)?1:0;
+                PORT_WRITE(out_SPR_WRITE_STATUS_VAL       [i][j], (id and status_val));
+              }
+          }
+      }
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_transition.cpp

-              r81
+              r88
   void Register_unit_Glue::transition (void)
+  {
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_unit_Glue,FUNCTION);
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
 …
 #endif
     log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
+    log_end(Register_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_vhdl_body.cpp

r81	r88
37	37	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
38	38	{
39		vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	39	vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
40	40	}
41	41	vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_0_"+toString(j)+"_ACK and in_GPR_READ_STATUS_0_"+toString(j)+"_ACK;");
…	…
48	48	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
49	49	{
50		vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	50	vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
51	51	}
52	52	vhdl->set_body ("\tin_GPR_READ_REGISTERFILE_0_"+toString(j)+"_DATA;");
…	…
59	59	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
60	60	{
61		vhdl->set_body ("\tin_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	61	vhdl->set_body ("\tin_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
62	62	}
63	63	vhdl->set_body ("\tin_GPR_READ_STATUS_0_"+toString(j)+"_DATA_VAL;");
…	…
71	71	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
72	72	{
73		vhdl->set_body ("out_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	73	vhdl->set_body ("out_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
74	74	}
75	75	}
…	…
80	80	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
81	81	{
82		vhdl->set_body ("out_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	82	vhdl->set_body ("out_GPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_READ_"+toString(j)+"_VAL and in_GPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
83	83	}
84	84	}
…	…
102	102	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
103	103	{
104		vhdl->set_body ("\tin_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	104	vhdl->set_body ("\tin_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
105	105	}
106	106	vhdl->set_body ("\tin_GPR_WRITE_REGISTERFILE_0_"+toString(j)+"_ACK and in_GPR_WRITE_STATUS_0_"+toString(j)+"_ACK;");
…	…
114	114	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
115	115	{
116		vhdl->set_body ("out_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	116	vhdl->set_body ("out_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
117	117	}
118	118	}
…	…
123	123	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
124	124	{
125		vhdl->set_body ("out_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	125	vhdl->set_body ("out_GPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_GPR_WRITE_"+toString(j)+"_VAL and in_GPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_GPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
126	126	}
127	127	}
…	…
145	145	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
146	146	{
147		vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	147	vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
148	148	}
149	149	vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_0_"+toString(j)+"_ACK and in_SPR_READ_STATUS_0_"+toString(j)+"_ACK;");
…	…
156	156	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
157	157	{
158		vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	158	vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_DATA when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
159	159	}
160	160	vhdl->set_body ("\tin_SPR_READ_REGISTERFILE_0_"+toString(j)+"_DATA;");
…	…
167	167	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
168	168	{
169		vhdl->set_body ("\tin_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	169	vhdl->set_body ("\tin_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_DATA_VAL when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
170	170	}
171	171	vhdl->set_body ("\tin_SPR_READ_STATUS_0_"+toString(j)+"_DATA_VAL;");
…	…
179	179	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
180	180	{
181		vhdl->set_body ("out_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	181	vhdl->set_body ("out_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
182	182	}
183	183	}
…	…
188	188	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
189	189	{
190		vhdl->set_body ("out_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	190	vhdl->set_body ("out_SPR_READ_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_READ_"+toString(j)+"_VAL and in_SPR_READ_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_READ_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
191	191	}
192	192	}
…	…
210	210	for (uint32_t i=_param->_nb_ooo_engine-1; i>=1; i--)
211	211	{
212		vhdl->set_body ("\tin_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else");
	212	vhdl->set_body ("\tin_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else");
213	213	}
214	214	vhdl->set_body ("\tin_SPR_WRITE_REGISTERFILE_0_"+toString(j)+"_ACK and in_SPR_WRITE_STATUS_0_"+toString(j)+"_ACK;");
…	…
222	222	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
223	223	{
224		vhdl->set_body ("out_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	224	vhdl->set_body ("out_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
225	225	}
226	226	}
…	…
231	231	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
232	232	{
233		vhdl->set_body ("out_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(~~log2(_param->_nb_ooo_engine)~~,i)+" else '0';");
	233	vhdl->set_body ("out_SPR_WRITE_STATUS_"+toString(i)+"_"+toString(j)+"_VAL <= in_SPR_WRITE_"+toString(j)+"_VAL and in_SPR_WRITE_REGISTERFILE_"+toString(i)+"_"+toString(j)+"_ACK when in_SPR_WRITE_"+toString(j)+"_OOO_ENGINE_ID = "+std_logic_conv(_param->_size_ooo_engine_id,i)+" else '0';");
234	234	}
235	235	}

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Register_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/SelfTest/include/test.h

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
+#include "Common/include/Time.h"
 using namespace std;
 …
 void test    (string name,
               morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::Parameters * param);
-class Time
+{
-private : timeval time_begin;
-// private : timeval time_end;
-public  : Time ()
+  {
-    gettimeofday(&time_begin     ,NULL);
-  };
-public  : ~Time ()
+  {
-    cout << *this;
-  };
-public  : friend ostream& operator<< (ostream& output_stream,
-                                      const Time & x)
+  {
-    timeval time_end;
-    gettimeofday(&time_end       ,NULL);
-    uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
-    double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec);
-    output_stream << nb_cycles << "\t(" << average << " cycles / seconds )" << endl;
-    return output_stream;
+  }
-};

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_special_register       ,
          _nb_inst_insert_rob        ,
+         _nb_inst_retire_rob        );
+         _nb_inst_retire_rob        ,
+         true //is_toplevel
+         );
       cout << param->print(1);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Register_unit * _Register_unit = new Register_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tspecial_address_t>  ***  in_INSERT_ROB_RE_NUM_REG        ;
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL               ;
   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK               ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE        ;
   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE        ;
   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE        ;
   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE        ;
   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL               ;
+//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK               ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE        ;
+//   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE        ;
+//   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE        ;
+//   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
+//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE        ;
+//   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
   string rename = "signal";
 …
+       }
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       in_RETIRE_ROB_VAL            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
      out_RETIRE_ROB_ACK            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RD_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RD_OLD_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RE_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RE_OLD_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RD_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RD_NEW_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RE_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
       in_RETIRE_ROB_RE_NEW_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+       {
          uint32_t x=_param->_nb_inst_retire_rob [i];
           in_RETIRE_ROB_VAL            [i] = new sc_signal<Tcontrol_t        > * [x];
          out_RETIRE_ROB_ACK            [i] = new sc_signal<Tcontrol_t        > * [x];
           in_RETIRE_ROB_RD_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
           in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
           in_RETIRE_ROB_RE_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
           in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
           in_RETIRE_ROB_RD_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
           in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
           in_RETIRE_ROB_RE_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
           in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
          for (uint32_t j=0; j<x; j++)
+           {
               in_RETIRE_ROB_VAL            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
              out_RETIRE_ROB_ACK            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
               in_RETIRE_ROB_RD_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
               in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
               in_RETIRE_ROB_RE_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
               in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
               in_RETIRE_ROB_RD_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
               in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
               in_RETIRE_ROB_RE_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
               in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
+           }
+       }
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//       in_RETIRE_ROB_VAL            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
+//      out_RETIRE_ROB_ACK            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RD_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RD_OLD_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RE_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RE_OLD_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RD_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RD_NEW_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RE_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
+//       in_RETIRE_ROB_RE_NEW_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
+//      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//        {
+//       uint32_t x=_param->_nb_inst_retire_rob [i];
+//        in_RETIRE_ROB_VAL            [i] = new sc_signal<Tcontrol_t        > * [x];
+//       out_RETIRE_ROB_ACK            [i] = new sc_signal<Tcontrol_t        > * [x];
+//        in_RETIRE_ROB_RD_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
+//        in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
+//        in_RETIRE_ROB_RE_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
+//        in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
+//        in_RETIRE_ROB_RD_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
+//        in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
+//        in_RETIRE_ROB_RE_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
+//        in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
+//       for (uint32_t j=0; j<x; j++)
+//         {
+//            in_RETIRE_ROB_VAL            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
+//           out_RETIRE_ROB_ACK            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
+//            in_RETIRE_ROB_RD_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
+//            in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
+//            in_RETIRE_ROB_RE_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
+//            in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
+//            in_RETIRE_ROB_RD_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
+//            in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
+//            in_RETIRE_ROB_RE_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
+//            in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
+//         }
+//        }
 …
         (*(_Register_unit-> in_INSERT_ROB_RE_NUM_REG [i][j]))(*( in_INSERT_ROB_RE_NUM_REG [i][j]));
+      }
   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
     for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+      {
         (*(_Register_unit-> in_RETIRE_ROB_VAL            [i][j]))(*( in_RETIRE_ROB_VAL            [i][j]));
         (*(_Register_unit->out_RETIRE_ROB_ACK            [i][j]))(*(out_RETIRE_ROB_ACK            [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE     [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE     [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE     [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE     [i][j]));
         (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]));
+      }
+//   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//     for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+//       {
+//      (*(_Register_unit-> in_RETIRE_ROB_VAL            [i][j]))(*( in_RETIRE_ROB_VAL            [i][j]));
+//      (*(_Register_unit->out_RETIRE_ROB_ACK            [i][j]))(*(out_RETIRE_ROB_ACK            [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE     [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE     [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE     [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE     [i][j]));
+//      (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]));
+//       }
   cout << "<" << name << "> Start Simulation ............" << endl;
 …
   const  int32_t percent_transaction_insert     = 70;
   const  int32_t percent_transaction_insert_use = 70;
   const  int32_t percent_transaction_retire     = 70;
   const  int32_t percent_transaction_retire_use = 70;
+//   const  int32_t percent_transaction_retire     = 70;
+//   const  int32_t percent_transaction_retire_use = 70;
   const uint32_t nb_request                     = max_nb_general_register;
 …
       for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
         in_INSERT_ROB_VAL [i][j]->write(0);
       for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
         in_RETIRE_ROB_VAL [i][j]->write(0);
+//       for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+//      in_RETIRE_ROB_VAL [i][j]->write(0);
+    }
 …
+        }
       LABEL("retire rob");
       cpt = 0;
       while (cpt < nb_request)
+        {
           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+            {
               uint32_t x=_param->_nb_inst_retire_rob [i];
               for (uint32_t j=0; j<x; j++)
+                {
                   in_RETIRE_ROB_VAL            [i][j]->write((rand() % 100) < percent_transaction_retire);
                   in_RETIRE_ROB_RD_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
                   in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
                   in_RETIRE_ROB_RD_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
                   in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
                   in_RETIRE_ROB_RE_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
                   in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);
                   in_RETIRE_ROB_RE_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
                   in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);
+                }
+            }
           SC_START(1);
           for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+            {
               uint32_t x=_param->_nb_inst_retire_rob [i];
               for (uint32_t j=0; j<x; j++)
+                {
                   if (in_RETIRE_ROB_VAL [i][j]->read() and out_RETIRE_ROB_ACK [i][j]->read())
+                    {
                       cpt ++;
+//       LABEL("retire rob");
+//       cpt = 0;
+//       while (cpt < nb_request)
+//      {
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          {
+//            uint32_t x=_param->_nb_inst_retire_rob [i];
+//            for (uint32_t j=0; j<x; j++)
+//              {
+//                in_RETIRE_ROB_VAL            [i][j]->write((rand() % 100) < percent_transaction_retire);
+//                in_RETIRE_ROB_RD_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
+//                in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
+//                in_RETIRE_ROB_RD_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
+//                in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
+//                in_RETIRE_ROB_RE_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
+//                in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);
+//                in_RETIRE_ROB_RE_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
+//                in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);
+//              }
+//          }
+//        SC_START(1);
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//          {
+//            uint32_t x=_param->_nb_inst_retire_rob [i];
+//            for (uint32_t j=0; j<x; j++)
+//              {
+//                if (in_RETIRE_ROB_VAL [i][j]->read() and out_RETIRE_ROB_ACK [i][j]->read())
+//                  {
+//                    cpt ++;
                       if (in_RETIRE_ROB_RD_OLD_USE [i][j]->read())
                         gpr_status [i][in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->read()] = 0;
                       if (in_RETIRE_ROB_RD_NEW_USE [i][j]->read())
                         gpr_status [i][in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->read()] = 1;
                       if (in_RETIRE_ROB_RE_OLD_USE [i][j]->read())
                         spr_status [i][in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->read()] = 0;
                       if (in_RETIRE_ROB_RE_NEW_USE [i][j]->read())
                         spr_status [i][in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->read()] = 1;
+                    }
+                }
+            }
+        }
       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
         for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
           in_RETIRE_ROB_VAL [i][j]->write(0);
+//                    if (in_RETIRE_ROB_RD_OLD_USE [i][j]->read())
+//                      gpr_status [i][in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->read()] = 0;
+//                    if (in_RETIRE_ROB_RD_NEW_USE [i][j]->read())
+//                      gpr_status [i][in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->read()] = 1;
+//                    if (in_RETIRE_ROB_RE_OLD_USE [i][j]->read())
+//                      spr_status [i][in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->read()] = 0;
+//                    if (in_RETIRE_ROB_RE_NEW_USE [i][j]->read())
+//                      spr_status [i][in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->read()] = 1;
+//                  }
+//              }
+//          }
+//      }
+//       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//      for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+//        in_RETIRE_ROB_VAL [i][j]->write(0);
       LABEL("(GPR) Read - and test data writted");
 …
   delete []  in_INSERT_ROB_RE_USE            ;
   delete []  in_INSERT_ROB_RE_NUM_REG        ;
   delete []  in_RETIRE_ROB_VAL               ;
   delete [] out_RETIRE_ROB_ACK               ;
   delete []  in_RETIRE_ROB_RD_OLD_USE        ;
   delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
   delete []  in_RETIRE_ROB_RD_NEW_USE        ;
   delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
   delete []  in_RETIRE_ROB_RE_OLD_USE        ;
   delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
   delete []  in_RETIRE_ROB_RE_NEW_USE        ;
   delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
+//   delete []  in_RETIRE_ROB_VAL               ;
+//   delete [] out_RETIRE_ROB_ACK               ;
+//   delete []  in_RETIRE_ROB_RD_OLD_USE        ;
+//   delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
+//   delete []  in_RETIRE_ROB_RD_NEW_USE        ;
+//   delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
+//   delete []  in_RETIRE_ROB_RE_OLD_USE        ;
+//   delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
+//   delete []  in_RETIRE_ROB_RE_NEW_USE        ;
+//   delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Parameters.h

-              r81
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : const uint32_t    _nb_ooo_engine            ;
   public : const uint32_t    _size_general_data        ;
   public : const uint32_t    _size_special_data        ;
   public : const uint32_t    _nb_gpr_read              ;
   public : const uint32_t    _nb_gpr_write             ;
   public : const uint32_t    _nb_gpr_bank              ;
   public : const uint32_t    _nb_gpr_port_read_by_bank ;
   public : const uint32_t    _nb_gpr_port_write_by_bank;
   public : const uint32_t    _nb_spr_read              ;
   public : const uint32_t    _nb_spr_write             ;
   public : const uint32_t    _nb_spr_bank              ;
   public : const uint32_t    _nb_spr_port_read_by_bank ;
   public : const uint32_t    _nb_spr_port_write_by_bank;
   public : const uint32_t  * _nb_general_register      ;
   public : const uint32_t  * _nb_special_register      ;
   public : const uint32_t  * _nb_inst_insert_rob       ;
   public : const uint32_t  * _nb_inst_retire_rob       ;
+  public : uint32_t    _nb_ooo_engine            ;
+//public : uint32_t    _size_general_data        ;
+//public : uint32_t    _size_special_data        ;
+  public : uint32_t    _nb_gpr_read              ;
+  public : uint32_t    _nb_gpr_write             ;
+  public : uint32_t    _nb_gpr_bank              ;
+  public : uint32_t    _nb_gpr_port_read_by_bank ;
+  public : uint32_t    _nb_gpr_port_write_by_bank;
+  public : uint32_t    _nb_spr_read              ;
+  public : uint32_t    _nb_spr_write             ;
+  public : uint32_t    _nb_spr_bank              ;
+  public : uint32_t    _nb_spr_port_read_by_bank ;
+  public : uint32_t    _nb_spr_port_write_by_bank;
+  public : uint32_t  * _nb_general_register      ;
+  public : uint32_t  * _nb_special_register      ;
+  public : uint32_t  * _nb_inst_insert_rob       ;
+  public : uint32_t  * _nb_inst_retire_rob       ;
   public : const bool        _have_port_ooo_engine_id  ;
   public :       uint32_t    _size_gpr_address         ;
   public :       uint32_t    _size_spr_address         ;
+//public : bool        _have_port_ooo_engine_id  ;
+  public : uint32_t    _size_gpr_address         ;
+  public : uint32_t    _size_spr_address         ;
   public : morpheo::behavioural::generic::registerfile::Parameters                                                     ** _param_gpr        ;
 …
   public : morpheo::behavioural::generic::registerfile::Parameters                                                     ** _param_spr        ;
   public : morpheo::behavioural::generic::registerfile::Parameters                                                     ** _param_spr_status ;
   public : morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_gpr       ;
   public : morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_gpr_status;
   public : morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_spr       ;
   public : morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_spr_status;
+  private: morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_gpr       ;
+  private: morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_gpr_status;
+  private: morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters                          ** __param_spr       ;
+  private: morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters                          ** __param_spr_status;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters  * _param_glue       ;
 …
                         uint32_t  * nb_special_register      ,
                         uint32_t  * nb_inst_insert_rob       ,
+                        uint32_t  * nb_inst_retire_rob       );
+                        uint32_t  * nb_inst_retire_rob       ,
+                        bool        is_toplevel=false);
   public : Parameters  (Parameters & param) ;
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string   print      (uint32_t depth);
   public : friend std::ostream& operator<< (std::ostream& output_stream,

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h

-              r82
+              r88
   public    : SC_IN (Tspecial_address_t)  ***  in_INSERT_ROB_RE_NUM_REG        ;
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL               ;
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK               ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE        ;
   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE        ;
   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE        ;
   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE        ;
   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL               ;
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK               ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE        ;
+//   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE        ;
+//   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE        ;
+//   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE        ;
+//   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t  * nb_special_register      ,
                           uint32_t  * nb_inst_insert_rob       ,
+                          uint32_t  * nb_inst_retire_rob       ):
+    _nb_ooo_engine             (nb_ooo_engine            ),
+    _size_general_data         (size_general_data        ),
+    _size_special_data         (size_special_data        ),
+    _nb_gpr_read               (nb_gpr_read              ),
+    _nb_gpr_write              (nb_gpr_write             ),
+    _nb_gpr_bank               (nb_gpr_bank              ),
+    _nb_gpr_port_read_by_bank  (nb_gpr_port_read_by_bank ),
+    _nb_gpr_port_write_by_bank (nb_gpr_port_write_by_bank),
+    _nb_spr_read               (nb_spr_read              ),
+    _nb_spr_write              (nb_spr_write             ),
+    _nb_spr_bank               (nb_spr_bank              ),
+    _nb_spr_port_read_by_bank  (nb_spr_port_read_by_bank ),
+    _nb_spr_port_write_by_bank (nb_spr_port_write_by_bank),
+    _nb_general_register       (nb_general_register      ),
+    _nb_special_register       (nb_special_register      ),
+    _nb_inst_insert_rob        (nb_inst_insert_rob       ),
+    _nb_inst_retire_rob        (nb_inst_retire_rob       ),
+    _have_port_ooo_engine_id   (nb_ooo_engine>1          )
+                          uint32_t  * nb_inst_retire_rob       ,
+                          bool        is_toplevel              )
+  {
     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+    _nb_ooo_engine             = nb_ooo_engine            ;
+    _nb_gpr_read               = nb_gpr_read              ;
+    _nb_gpr_write              = nb_gpr_write             ;
+    _nb_gpr_bank               = nb_gpr_bank              ;
+    _nb_gpr_port_read_by_bank  = nb_gpr_port_read_by_bank ;
+    _nb_gpr_port_write_by_bank = nb_gpr_port_write_by_bank;
+    _nb_spr_read               = nb_spr_read              ;
+    _nb_spr_write              = nb_spr_write             ;
+    _nb_spr_bank               = nb_spr_bank              ;
+    _nb_spr_port_read_by_bank  = nb_spr_port_read_by_bank ;
+    _nb_spr_port_write_by_bank = nb_spr_port_write_by_bank;
+    _nb_general_register       = nb_general_register      ;
+    _nb_special_register       = nb_special_register      ;
+    _nb_inst_insert_rob        = nb_inst_insert_rob       ;
+    _nb_inst_retire_rob        = nb_inst_retire_rob       ;
     _size_gpr_address = log2(nb_general_register [0]);
 …
           _size_spr_address = new_size;
+      }
     _param_gpr         = new morpheo::behavioural::generic::registerfile::Parameters * [_nb_ooo_engine];
 …
     __param_spr_status = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters * [_nb_ooo_engine];
+   for (uint32_t i=0; i<_nb_ooo_engine; i++)
+     {
+       Tcrossbar_t crossbar = PARTIAL_CROSSBAR;
+       __param_gpr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
+         (_nb_gpr_read              ,
+          _nb_gpr_write             ,
+          _nb_general_register[i]   ,
+          _size_general_data        ,
+          _nb_gpr_bank              ,
+          _nb_gpr_port_read_by_bank ,
+          _nb_gpr_port_write_by_bank,
+          crossbar                  );
+       __param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
+         (_nb_gpr_read ,
+          _nb_gpr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
+,
+          nb_general_register[i],
+);
+       __param_spr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
+         (_nb_spr_read              ,
+          _nb_spr_write             ,
+          _nb_special_register[i]   ,
+          _size_special_data        ,
+          _nb_spr_bank              ,
+          _nb_spr_port_read_by_bank ,
+          _nb_spr_port_write_by_bank,
+          crossbar                  );
+       __param_spr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
+         (_nb_spr_read ,
+          _nb_spr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
+,
+          nb_special_register[i],
+);
+       _param_gpr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr        [i]);
+       _param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr_status [i]);
+       _param_spr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr        [i]);
+       _param_spr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr_status [i]);
+     }
+   _param_glue       = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters  (_nb_ooo_engine        ,
+                                                                                                                                         _size_general_data    ,
+                                                                                                                                         _size_special_data    ,
+                                                                                                                                         _nb_gpr_read          ,
+                                                                                                                                         _nb_spr_read          ,
+                                                                                                                                         _nb_gpr_write         ,
+                                                                                                                                         _nb_spr_write         ,
+                                                                                                                                         _nb_inst_insert_rob   ,
+                                                                                                                                         _nb_inst_retire_rob   );
+    for (uint32_t i=0; i<_nb_ooo_engine; i++)
+      {
+        Tcrossbar_t crossbar = PARTIAL_CROSSBAR;
+        __param_gpr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
+          (_nb_gpr_read              ,
+           _nb_gpr_write             ,
+           _nb_general_register[i]   ,
+            size_general_data        ,
+           _nb_gpr_bank              ,
+           _nb_gpr_port_read_by_bank ,
+           _nb_gpr_port_write_by_bank,
+           crossbar                  );
+        __param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
+          (_nb_gpr_read ,
+//         _nb_gpr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
+           _nb_gpr_write+_nb_inst_insert_rob[i],
+,
+           nb_general_register[i],
+);
+        __param_spr        [i] = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
+          (_nb_spr_read              ,
+           _nb_spr_write             ,
+           _nb_special_register[i]   ,
+            size_special_data        ,
+           _nb_spr_bank              ,
+           _nb_spr_port_read_by_bank ,
+           _nb_spr_port_write_by_bank,
+           crossbar                  );
+        __param_spr_status [i] = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
+          (_nb_spr_read ,
+//         _nb_spr_write+_nb_inst_insert_rob[i]+2*_nb_inst_retire_rob[i],
+           _nb_spr_write+_nb_inst_insert_rob[i],
+,
+           nb_special_register[i],
+);
+        _param_gpr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr        [i]);
+        _param_gpr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_gpr_status [i]);
+        _param_spr        [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr        [i]);
+        _param_spr_status [i] = new morpheo::behavioural::generic::registerfile::Parameters (__param_spr_status [i]);
+      }
+    _param_glue       = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters  (_nb_ooo_engine        ,
+                                                                                                                                           size_general_data    ,
+                                                                                                                                           size_special_data    ,
+                                                                                                                                          _nb_gpr_read          ,
+                                                                                                                                          _nb_spr_read          ,
+                                                                                                                                          _nb_gpr_write         ,
+                                                                                                                                          _nb_spr_write         ,
+                                                                                                                                          _nb_inst_insert_rob   ,
+                                                                                                                                          _nb_inst_retire_rob   );
     test();
+    log_printf(FUNC,Register_unit,FUNCTION,"End");
+    if (is_toplevel)
+      {
+        _size_ooo_engine_id        = log2(nb_ooo_engine);
+        _size_general_data         = size_general_data;
+        _size_special_data         = size_special_data;
+        _have_port_ooo_engine_id   = _size_ooo_engine_id > 0;
+        copy();
+      }
+   log_printf(FUNC,Register_unit,FUNCTION,"End");
   };
+// #undef  FUNCTION
+// #define FUNCTION "Register_unit::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _nb_ooo_engine             (param._nb_ooo_engine            ),
+//     _size_general_data         (param._size_general_data        ),
+//     _size_special_data         (param._size_special_data        ),
+//     _nb_gpr_read               (param._nb_gpr_read              ),
+//     _nb_gpr_write              (param._nb_gpr_write             ),
+//     _nb_gpr_bank               (param._nb_gpr_bank              ),
+//     _nb_gpr_port_read_by_bank  (param._nb_gpr_port_read_by_bank ),
+//     _nb_gpr_port_write_by_bank (param._nb_gpr_port_write_by_bank),
+//     _nb_spr_read               (param._nb_spr_read              ),
+//     _nb_spr_write              (param._nb_spr_write             ),
+//     _nb_spr_bank               (param._nb_spr_bank              ),
+//     _nb_spr_port_read_by_bank  (param._nb_spr_port_read_by_bank ),
+//     _nb_spr_port_write_by_bank (param._nb_spr_port_write_by_bank),
+//     _nb_general_register       (param._nb_general_register      ),
+//     _nb_special_register       (param._nb_special_register      ),
+//     _nb_inst_insert_rob        (param._nb_inst_insert_rob       ),
+//     _nb_inst_retire_rob        (param._nb_inst_retire_rob       ),
+//     _have_port_ooo_engine_id   (param._have_port_ooo_engine_id  )
+//   {
+//     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+//     _size_gpr_address = param._size_gpr_address;
+//     _size_spr_address = param._size_spr_address;
+//     __param_gpr        = param.__param_gpr       ;
+//     __param_gpr_status = param.__param_gpr_status;
+//     __param_spr        = param.__param_spr       ;
+//     __param_spr_status = param.__param_spr_status;
+//     _param_gpr         = param._param_gpr       ;
+//     _param_gpr_status  = param._param_gpr_status;
+//     _param_spr         = param._param_spr       ;
+//     _param_spr_status  = param._param_spr_status;
+//     _param_glue        = param._param_glue      ;
+//     test();
+//     log_printf(FUNC,Register_unit,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Register_unit::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _nb_ooo_engine             (param._nb_ooo_engine            ),
+    _size_general_data         (param._size_general_data        ),
+    _size_special_data         (param._size_special_data        ),
+    _nb_gpr_read               (param._nb_gpr_read              ),
+    _nb_gpr_write              (param._nb_gpr_write             ),
+    _nb_gpr_bank               (param._nb_gpr_bank              ),
+    _nb_gpr_port_read_by_bank  (param._nb_gpr_port_read_by_bank ),
+    _nb_gpr_port_write_by_bank (param._nb_gpr_port_write_by_bank),
+    _nb_spr_read               (param._nb_spr_read              ),
+    _nb_spr_write              (param._nb_spr_write             ),
+    _nb_spr_bank               (param._nb_spr_bank              ),
+    _nb_spr_port_read_by_bank  (param._nb_spr_port_read_by_bank ),
+    _nb_spr_port_write_by_bank (param._nb_spr_port_write_by_bank),
+    _nb_general_register       (param._nb_general_register      ),
+    _nb_special_register       (param._nb_special_register      ),
+    _nb_inst_insert_rob        (param._nb_inst_insert_rob       ),
+    _nb_inst_retire_rob        (param._nb_inst_retire_rob       ),
+    _have_port_ooo_engine_id   (param._have_port_ooo_engine_id  )
+#define FUNCTION "Register_unit::~Parameters"
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+    _size_gpr_address = param._size_gpr_address;
+    _size_spr_address = param._size_spr_address;
+    __param_gpr        = param.__param_gpr       ;
+    __param_gpr_status = param.__param_gpr_status;
+    __param_spr        = param.__param_spr       ;
+    __param_spr_status = param.__param_spr_status;
+    _param_gpr         = param._param_gpr       ;
+    _param_gpr_status  = param._param_gpr_status;
+    _param_spr         = param._param_spr       ;
+    _param_spr_status  = param._param_spr_status;
+    _param_glue        = param._param_glue      ;
+    test();
+    log_printf(FUNC,Register_unit,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Register_unit::~Parameters"
+  Parameters::~Parameters ()
+  {
+    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+    delete [] _param_gpr       ;
+    delete [] _param_gpr_status;
+    delete [] _param_spr       ;
+    delete [] _param_spr_status;
+    for (uint32_t i=0; i<_nb_ooo_engine; i++)
+      {
+        delete _param_gpr         [i];
+        delete _param_gpr_status  [i];
+        delete _param_spr         [i];
+        delete _param_spr_status  [i];
+        delete __param_gpr        [i];
+        delete __param_gpr_status [i];
+        delete __param_spr        [i];
+        delete __param_spr_status [i];
+      }
+    delete [] _param_gpr        ;
+    delete [] _param_gpr_status ;
+    delete [] _param_spr        ;
+    delete [] _param_spr_status ;
     delete [] __param_gpr       ;
     delete [] __param_gpr_status;
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Register_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+    for (uint32_t i=0; i<_nb_ooo_engine; i++)
+      {
+        COPY(__param_gpr        [i]);
+        COPY(__param_gpr_status [i]);
+        COPY(__param_spr        [i]);
+        COPY(__param_spr_status [i]);
+      }
+    COPY(_param_glue);
+    log_printf(FUNC,Register_unit,FUNCTION,"End");
+  };
 }; // end namespace register_unit
 }; // end namespace execute_loop

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+#if DEBUG_Register_unit == true
+    log_printf(INFO,Register_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Register_unit,FUNCTION,"Allocation");
     allocation (
 …
 #ifdef STATISTICS
+    log_printf(INFO,Register_unit,FUNCTION,"Allocation of statistics");
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Register_unit,FUNCTION,_("<%s> : Allocation of statistics"),_name.c_str());
+    // Allocation of statistics
     statistics_declaration(param_statistics);
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,Register_unit,FUNCTION,"Generate the vhdl");
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,Register_unit,FUNCTION,"Generate the vhdl");
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     log_printf(INFO,Register_unit,FUNCTION,"Method - transition");
 …
     // List dependency information
 #endif
+      }
 #endif
     log_printf(FUNC,Register_unit,FUNCTION,"End");
 …
 #ifdef STATISTICS
+    log_printf(INFO,Register_unit,FUNCTION,"Generate Statistics file");
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Register_unit,FUNCTION,"Generate Statistics file");
+        delete _stat;
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_allocation.cpp

-              r82
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/include/Register_unit.h"
 namespace morpheo                    {
+namespace morpheo {
 namespace behavioural {
 namespace core {
 …
 namespace execute_loop {
 namespace register_unit {
 #undef  FUNCTION
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     Interface * interface = _interfaces->set_interface(""
 …
     in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
     // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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];
 …
         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" , log2(_param->_nb_ooo_engine));
+          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);
 …
+      }
     // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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];
 …
         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" , log2(_param->_nb_ooo_engine));
+          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);
+      }
     // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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];
 …
         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" , log2(_param->_nb_ooo_engine));
+          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);
 …
+      }
     // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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];
 …
         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" , log2(_param->_nb_ooo_engine));
+          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" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ 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];
 …
+      }
+    // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    in_RETIRE_ROB_VAL            = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+    out_RETIRE_ROB_ACK            = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RD_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RD_OLD_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RE_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RE_OLD_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RD_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RD_NEW_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RE_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+    in_RETIRE_ROB_RE_NEW_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_retire_rob [i];
+        in_RETIRE_ROB_VAL            [i] = new SC_IN (Tcontrol_t        )  * [x];
+        out_RETIRE_ROB_ACK            [i] = new SC_OUT(Tcontrol_t        )  * [x];
+        in_RETIRE_ROB_RD_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+        in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
+        in_RETIRE_ROB_RE_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+        in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
+        in_RETIRE_ROB_RD_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+        in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
+        in_RETIRE_ROB_RE_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+        in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
+        for (uint32_t j=0; j<x; j++)
+          {
+            Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
+#ifdef POSITION
+                                                                    ,IN
+                                                                    ,WEST
+                                                                    ,"Interface to update status (retire)"
+#endif
+                                                                    );
+            in_RETIRE_ROB_VAL            [i][j] = interface->set_signal_valack_in  (VAL);
+           out_RETIRE_ROB_ACK            [i][j] = interface->set_signal_valack_out (ACK);
+            in_RETIRE_ROB_RD_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_old_use"    , 1);
+            in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_old_num_reg", _param->_size_gpr_address);
+            in_RETIRE_ROB_RE_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_old_use"    , 1);
+            in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_old_num_reg", _param->_size_spr_address);
+            in_RETIRE_ROB_RD_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_new_use"    , 1);
+            in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_new_num_reg", _param->_size_gpr_address);
+            in_RETIRE_ROB_RE_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_new_use"    , 1);
+            in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_new_num_reg", _param->_size_spr_address);
+          }
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//     in_RETIRE_ROB_VAL            = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+//     out_RETIRE_ROB_ACK            = new SC_OUT(Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_OLD_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_OLD_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_OLD_NUM_REG = new SC_IN (Tspecial_address_t)  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RD_NEW_NUM_REG = new SC_IN (Tgeneral_address_t)  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_NEW_USE     = new SC_IN (Tcontrol_t        )  ** [_param->_nb_ooo_engine];
+//     in_RETIRE_ROB_RE_NEW_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_retire_rob [i];
+//      in_RETIRE_ROB_VAL            [i] = new SC_IN (Tcontrol_t        )  * [x];
+//      out_RETIRE_ROB_ACK            [i] = new SC_OUT(Tcontrol_t        )  * [x];
+//      in_RETIRE_ROB_RD_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+//      in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
+//      in_RETIRE_ROB_RE_OLD_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+//      in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
+//      in_RETIRE_ROB_RD_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+//      in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new SC_IN (Tgeneral_address_t)  * [x];
+//      in_RETIRE_ROB_RE_NEW_USE     [i] = new SC_IN (Tcontrol_t        )  * [x];
+//      in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new SC_IN (Tspecial_address_t)  * [x];
+//      for (uint32_t j=0; j<x; j++)
+//        {
+//          Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
+// #ifdef POSITION
+//                                                                  ,IN
+//                                                                  ,WEST
+//                                                                  ,"Interface to update status (retire)"
+// #endif
+//                                                                  );
+//          in_RETIRE_ROB_VAL            [i][j] = interface->set_signal_valack_in  (VAL);
+//         out_RETIRE_ROB_ACK            [i][j] = interface->set_signal_valack_out (ACK);
+//          in_RETIRE_ROB_RD_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_old_use"    , 1);
+//          in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_old_num_reg", _param->_size_gpr_address);
+//          in_RETIRE_ROB_RE_OLD_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_old_use"    , 1);
+//          in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_old_num_reg", _param->_size_spr_address);
+//          in_RETIRE_ROB_RD_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("rd_new_use"    , 1);
+//          in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = interface->set_signal_in <Tgeneral_address_t> ("rd_new_num_reg", _param->_size_gpr_address);
+//          in_RETIRE_ROB_RE_NEW_USE     [i][j] = interface->set_signal_in <Tcontrol_t        > ("re_new_use"    , 1);
+//          in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = interface->set_signal_in <Tspecial_address_t> ("re_new_num_reg", _param->_size_spr_address);
+//        }
+//       }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     std::string name;
 …
+      {
         name = _name+"_gpr_"+toString(i);
+        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
         component_gpr        [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
 …
         name = _name+"_gpr_status_"+toString(i);
+        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
         component_gpr_status [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
 …
         name = _name+"_spr_"+toString(i);
+        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
         component_spr        [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
 …
         name = _name+"_spr_status_"+toString(i);
+        log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
         component_spr_status [i] = new morpheo::behavioural::generic::registerfile::RegisterFile::RegisterFile
 …
     name = _name+"_glue";
+    log_printf(INFO,Register_unit,FUNCTION,_("Create   : %s"),name.c_str());
     component_glue       = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Register_unit_Glue::Register_unit_Glue
 …
         name_component = _name+"_gpr_"+toString(i);
         std::cout << "Instance : " << name_component << std::endl;
+        log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
 #ifdef POSITION
 …
           name_component = _name+"_gpr_status_"+toString(i);
           std::cout << "Instance : " << name_component << std::endl;
+          log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
 #ifdef POSITION
 …
+            }
           for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+            {
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_VAL" ,
                                    _name+"_glue",
                                    "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
               _component->port_map(name_component,
                                    "out_WRITE_"+toString(x)+"_ACK",
                                    _name+"_glue",
                                    "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_DATA" ,
                                    _name+"_glue",
                                    "out_CONST_0");
               _component->port_map(_name+"_glue",
                                    "out_CONST_0",
                                    name_component,
                                    "in_WRITE_"+toString(x)+"_DATA" );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG");
+//        for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+//          {
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_VAL" ,
+//                                 _name+"_glue",
+//                                 "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "out_WRITE_"+toString(x)+"_ACK",
+//                                 _name+"_glue",
+//                                 "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA" ,
+//                                 _name+"_glue",
+//                                 "out_CONST_0");
+//            _component->port_map(_name+"_glue",
+//                                 "out_CONST_0",
+//                                 name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA" );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG");
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_VAL" ,
                                    _name+"_glue",
                                    "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
               _component->port_map(name_component,
                                    "out_WRITE_"+toString(x)+"_ACK",
                                    _name+"_glue",
                                    "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_DATA" ,
                                    _name+"_glue",
                                    "out_CONST_1"
                                    );
               _component->port_map(_name+"_glue",
                                    "out_CONST_1",
                                    name_component,
                                    "in_WRITE_"+toString(x)+"_DATA"
                                    );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG");
+            }
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_VAL" ,
+//                                 _name+"_glue",
+//                                 "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "out_WRITE_"+toString(x)+"_ACK",
+//                                 _name+"_glue",
+//                                 "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA" ,
+//                                 _name+"_glue",
+//                                 "out_CONST_1"
+//                                 );
+//            _component->port_map(_name+"_glue",
+//                                 "out_CONST_1",
+//                                 name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA"
+//                                 );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG");
+//          }
+        }
 …
         name_component = _name+"_spr_"+toString(i);
         std::cout << "Instance : " << name_component << std::endl;
+        log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
 #ifdef POSITION
 …
           name_component = _name+"_spr_status_"+toString(i);
           std::cout << "Instance : " << name_component << std::endl;
+          log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
 #ifdef POSITION
           _component->interface_map (name_component,"",
 …
+            }
           for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+            {
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_VAL" ,
                                    _name+"_glue",
                                    "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
               _component->port_map(name_component,
                                    "out_WRITE_"+toString(x)+"_ACK",
                                    _name+"_glue",
                                    "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_DATA" ,
                                    _name+"_glue",
                                    "out_CONST_0");
               _component->port_map(_name+"_glue",
                                    "out_CONST_0",
                                    name_component,
                                    "in_WRITE_"+toString(x)+"_DATA"
                                    );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG");
+//        for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
+//          {
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_VAL" ,
+//                                 _name+"_glue",
+//                                 "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "out_WRITE_"+toString(x)+"_ACK",
+//                                 _name+"_glue",
+//                                 "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK" );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA" ,
+//                                 _name+"_glue",
+//                                 "out_CONST_0");
+//            _component->port_map(_name+"_glue",
+//                                 "out_CONST_0",
+//                                 name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA"
+//                                 );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG");
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_VAL" ,
                                    _name+"_glue",
                                    "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
               _component->port_map(name_component,
                                    "out_WRITE_"+toString(x)+"_ACK",
                                    _name+"_glue",
                                    "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x)+"_DATA" ,
                                    _name+"_glue",
                                    "out_CONST_1"
                                    );
               _component->port_map(_name+"_glue",
                                    "out_CONST_1",
                                    name_component,
                                    "in_WRITE_"+toString(x)+"_DATA"
                                    );
               _component->port_map(name_component,
                                    "in_WRITE_"+toString(x++)+"_ADDRESS",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG");
+            }
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_VAL" ,
+//                                 _name+"_glue",
+//                                 "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "out_WRITE_"+toString(x)+"_ACK",
+//                                 _name+"_glue",
+//                                 "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK" );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA" ,
+//                                 _name+"_glue",
+//                                 "out_CONST_1"
+//                                 );
+//            _component->port_map(_name+"_glue",
+//                                 "out_CONST_1",
+//                                 name_component,
+//                                 "in_WRITE_"+toString(x)+"_DATA"
+//                                 );
+//            _component->port_map(name_component,
+//                                 "in_WRITE_"+toString(x++)+"_ADDRESS",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG");
+//          }
+        }
 …
       name_component = _name+"_glue";
       std::cout << "Instance : " << name_component << std::endl;
+      log_printf(INFO,Register_unit,FUNCTION,_("Instance : %s"),name_component.c_str());
 #ifdef POSITION
       _component->interface_map (name_component,"",
 …
+        }
       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        {
           uint32_t x     =_param->_nb_inst_retire_rob [i];
           uint32_t gpr_j = _param->_nb_gpr_write + _param->_nb_inst_insert_rob [i];
           uint32_t spr_j = _param->_nb_spr_write + _param->_nb_inst_insert_rob [i];
           for (uint32_t j=0; j<x; j++)
+            {
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL");
               _component->port_map(name_component,
                                    "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK",
                                    _name,
                                    "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE",
                                    _name,
                                    "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE");
+//       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//      {
+//        uint32_t x     =_param->_nb_inst_retire_rob [i];
+//        uint32_t gpr_j = _param->_nb_gpr_write + _param->_nb_inst_insert_rob [i];
+//        uint32_t spr_j = _param->_nb_spr_write + _param->_nb_inst_insert_rob [i];
+//        for (uint32_t j=0; j<x; j++)
+//          {
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK",
+//                                 _name,
+//                                 "out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE",
+//                                 _name,
+//                                 "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE");
               _component->port_map(name_component,
                                    "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
                                    _name+"_gpr_status_"+toString(i),
                                    "in_WRITE_"+toString(gpr_j)+"_VAL");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
                                    _name+"_gpr_status_"+toString(i),
                                    "out_WRITE_"+toString(gpr_j++)+"_ACK");
               _component->port_map(name_component,
                                    "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
                                    _name+"_gpr_status_"+toString(i),
                                    "in_WRITE_"+toString(gpr_j)+"_VAL");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
                                    _name+"_gpr_status_"+toString(i),
                                    "out_WRITE_"+toString(gpr_j++)+"_ACK");
               _component->port_map(name_component,
                                    "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
                                    _name+"_spr_status_"+toString(i),
                                    "in_WRITE_"+toString(spr_j)+"_VAL");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
                                    _name+"_spr_status_"+toString(i),
                                    "out_WRITE_"+toString(spr_j++)+"_ACK");
               _component->port_map(name_component,
                                    "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
                                    _name+"_spr_status_"+toString(i),
                                    "in_WRITE_"+toString(spr_j)+"_VAL");
               _component->port_map(name_component,
                                    "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
                                    _name+"_spr_status_"+toString(i),
                                    "out_WRITE_"+toString(spr_j++)+"_ACK");
+            }
+        }
+//            _component->port_map(name_component,
+//                                 "out_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
+//                                 _name+"_gpr_status_"+toString(i),
+//                                 "in_WRITE_"+toString(gpr_j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_GPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
+//                                 _name+"_gpr_status_"+toString(i),
+//                                 "out_WRITE_"+toString(gpr_j++)+"_ACK");
+//            _component->port_map(name_component,
+//                                 "out_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
+//                                 _name+"_gpr_status_"+toString(i),
+//                                 "in_WRITE_"+toString(gpr_j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_GPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
+//                                 _name+"_gpr_status_"+toString(i),
+//                                 "out_WRITE_"+toString(gpr_j++)+"_ACK");
+//            _component->port_map(name_component,
+//                                 "out_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_VAL",
+//                                 _name+"_spr_status_"+toString(i),
+//                                 "in_WRITE_"+toString(spr_j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_SPR_STATUS_OLD_"+toString(i)+"_"+toString(j)+"_ACK",
+//                                 _name+"_spr_status_"+toString(i),
+//                                 "out_WRITE_"+toString(spr_j++)+"_ACK");
+//            _component->port_map(name_component,
+//                                 "out_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_VAL",
+//                                 _name+"_spr_status_"+toString(i),
+//                                 "in_WRITE_"+toString(spr_j)+"_VAL");
+//            _component->port_map(name_component,
+//                                 "in_RETIRE_ROB_SPR_STATUS_NEW_"+toString(i)+"_"+toString(j)+"_ACK",
+//                                 _name+"_spr_status_"+toString(i),
+//                                 "out_WRITE_"+toString(spr_j++)+"_ACK");
+//          }
+//      }
     }// glue
+//     _component->test_map ();
+#ifdef POSITION
+    _component->generate_file();
+#if DEBUG_Register_unit == true
+    _component->test_map ();
+#endif
+#ifdef POSITION
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Register_unit,FUNCTION,"Begin");
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 //#if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     delete     in_CLOCK ;
 …
     delete []  in_INSERT_ROB_RE_USE            ;
     delete []  in_INSERT_ROB_RE_NUM_REG        ;
+    delete []  in_RETIRE_ROB_VAL               ;
+    delete [] out_RETIRE_ROB_ACK               ;
+    delete []  in_RETIRE_ROB_RD_OLD_USE        ;
+    delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
+    delete []  in_RETIRE_ROB_RD_NEW_USE        ;
+    delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
+    delete []  in_RETIRE_ROB_RE_OLD_USE        ;
+    delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
+    delete []  in_RETIRE_ROB_RE_NEW_USE        ;
+    delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
+//     delete []  in_RETIRE_ROB_VAL               ;
+//     delete [] out_RETIRE_ROB_ACK               ;
+//     delete []  in_RETIRE_ROB_RD_OLD_USE        ;
+//     delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
+//     delete []  in_RETIRE_ROB_RD_NEW_USE        ;
+//     delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
+//     delete []  in_RETIRE_ROB_RE_OLD_USE        ;
+//     delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
+//     delete []  in_RETIRE_ROB_RE_NEW_USE        ;
+//     delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/src/Register_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/Makefile

r81	r88
24	24	library_clean : Execute_loop_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/config_min.cfg

-              r87
+              r88
       32      +1      # size_general_data
        2       +1      # size_special_data
+       1       +1      # size_read_queue                            [0]    [read_unit]
+       1       +1      # size_reservation_station                   [0]    [read_unit]
+       1       +1      # nb_inst_retire                             [0]    [read_unit]
+       2       +1      # size_store_queue                           [0]    [load_store_unit]
+       1       +1      # size_load_queue                            [0]    [load_store_unit]
+       1       +1      # size_speculative_access_queue              [0]    [load_store_unit]
+       1       +1      # nb_port_check                              [0]    [load_store_unit]
+       2       +1      # speculative_load                           [0]    [load_store_unit]
+       0       +1      # nb_bypass_memory                           [0]    [load_store_unit]
+       1       +1      # size_write_queue                           [0]    [write_unit]
+       1       +1      # size_execute_queue                         [0]    [write_unit]
+       1       +1      # nb_bypass_write                            [0]    [write_unit]
+       1       +1      # nb_gpr_bank
+       1       +1      # nb_gpr_port_read_by_bank
+       1       +1      # nb_gpr_port_write_by_bank
+       1       +1      # nb_spr_bank
+       1       +1      # nb_spr_port_read_by_bank
+       1       +1      # nb_spr_port_write_by_bank
+      64      +1      # nb_general_register                        [0]    [nb_ooo_engine]
+      16      +1      # nb_special_register                        [0]    [nb_ooo_engine]
+       1       +1      # nb_inst_insert_rob                         [0]    [nb_ooo_engine]
+       1       +1      # nb_inst_retire_rob                         [0]    [nb_ooo_engine]
+       1       +1      # execution_unit_to_write_unit_priority
+       1       +1      # execution_unit_to_write_unit_table_routing [0][0] [nb_execute_unit][nb_write_unit]
+       1       +1      # execution_unit_to_write_unit_table_routing [1][0] [nb_execute_unit][nb_write_unit]
+       1       +1      # execution_unit_to_write_unit_table_thread  [0][0] [nb_write_unit][nb_thread]
+       1       +1      # read_unit_to_execution_unit_priority
+       1       +1      # read_unit_to_execution_unit_table_routing  [0][0] [nb_read_unit][nb_execute_unit]
+       1       +1      # read_unit_to_execution_unit_table_routing  [0][1] [nb_read_unit][nb_execute_unit]
+       1       +1      # read_unit_to_execution_unit_table_thread   [0][0] [nb_execute_unit][nb_thread]
+       1       +1      # read_unit_to_execution_unit_table_thread   [1][0] [nb_execute_unit][nb_thread]
+       1       +1      # size_read_queue                            [0]       [nb_read_unit]
+       1       +1      # size_reservation_station                   [0]       [nb_read_unit]
+       1       +1      # nb_inst_retire                             [0]       [nb_read_unit]
+       1       +1      # nb_inst_functionnal_unit                   [0]       [nb_inst_functionnal]
+       2       +1      # size_store_queue                           [0]       [nb_load_store_unit]
+       1       +1      # size_load_queue                            [0]       [nb_load_store_unit]
+       1       +1      # size_speculative_access_queue              [0]       [nb_load_store_unit]
+       1       +1      # nb_port_check                              [0]       [nb_load_store_unit]
+       2       +1      # speculative_load                           [0]       [nb_load_store_unit]
+       0       +1      # nb_bypass_memory                           [0]       [nb_load_store_unit]
+       1       +1      # nb_cache_port                              [0]       [nb_load_store_unit]
+       1       +1      # nb_inst_memory                             [0]       [nb_load_store_unit]
+       1       +1      # size_write_queue                           [0]       [nb_write_unit]
+       1       +1      # size_execute_queue                         [0]       [nb_write_unit]
+       1       +1      # nb_bypass_write                            [0]       [nb_write_unit]
+       1       +1      # nb_gpr_bank
+       1       +1      # nb_gpr_port_read_by_bank
+       1       +1      # nb_gpr_port_write_by_bank
+       1       +1      # nb_spr_bank
+       1       +1      # nb_spr_port_read_by_bank
+       1       +1      # nb_spr_port_write_by_bank
+      64      +1      # nb_general_register                        [0]       [nb_ooo_engine]
+      16      +1      # nb_special_register                        [0]       [nb_ooo_engine]
+       1       +1      # nb_inst_insert_rob                         [0]       [nb_ooo_engine]
+       1       +1      # nb_inst_retire_rob                         [0]       [nb_ooo_engine]
+       1       +1      # execution_unit_to_write_unit_priority
+       1       +1      # execution_unit_to_write_unit_table_routing [0][0][0] [nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+       1       +1      # execution_unit_to_write_unit_table_routing [1][0][0] [nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+       1       +1      # execution_unit_to_write_unit_table_thread  [0][0]    [nb_write_unit][nb_thread]
+       1       +1      # read_unit_to_execution_unit_priority
+       1       +1      # read_unit_to_execution_unit_table_routing  [0][0][0] [nb_read_unit][nb_execute_unit][nb_execute_unit_port]
+       1       +1      # read_unit_to_execution_unit_table_routing  [0][1][0] [nb_read_unit][nb_execute_unit][nb_execute_unit_port]
+       1       +1      # read_unit_to_execution_unit_table_thread   [0][0]    [nb_execute_unit][nb_thread]
+       1       +1      # read_unit_to_execution_unit_table_thread   [1][0]    [nb_execute_unit][nb_thread]
+       0       +1      # is_load_store_unit                         [0]       [nb_execute_unit]
+       1       +1      # is_load_store_unit                         [1]       [nb_execute_unit]
+       0       +1      # translate_num_execute_unit                 [0]       [nb_execute_unit]
+       0       +1      # translate_num_execute_unit                 [1]       [nb_execute_unit]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/include/test.h

r81	r88
16	16
17	17	#include "Common/include/Time.h"
	18	#include "Behavioural/include/Selftest.h"
18	19	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Execute_loop.h"
19	20

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/src/main.cpp

-              r81
+              r88
   err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
   err (_("list_params is :\n"));
+  err (_(" * nb_read_unit                                                               (uint32_t           )\n"));
+  err (_(" * nb_functionnal_unit                                                        (uint32_t           )\n"));
+  err (_(" * nb_load_store_unit                                                         (uint32_t           )\n"));
+  err (_(" * nb_write_unit                                                              (uint32_t           )\n"));
+  err (_(" * nb_context                                                                 (uint32_t           )\n"));
+  err (_(" * nb_front_end                                                               (uint32_t           )\n"));
+  err (_(" * nb_ooo_engine                                                              (uint32_t           )\n"));
+  err (_(" * nb_packet                                                                  (uint32_t           )\n"));
+  err (_(" * size_general_data                                                          (uint32_t           )\n"));
+  err (_(" * size_special_data                                                          (uint32_t           )\n"));
+  err (_(" * size_read_queue                           [read_unit]                      (uint32_t           )\n"));
+  err (_(" * size_reservation_station                  [read_unit]                      (uint32_t           )\n"));
+  err (_(" * nb_inst_retire                            [read_unit]                      (uint32_t           )\n"));
+  err (_(" * size_store_queue                          [load_store_unit]                (uint32_t           )\n"));
+  err (_(" * size_load_queue                           [load_store_unit]                (uint32_t           )\n"));
+  err (_(" * size_speculative_access_queue             [load_store_unit]                (uint32_t           )\n"));
+  err (_(" * nb_port_check                             [load_store_unit]                (uint32_t           )\n"));
+  err (_(" * speculative_load                          [load_store_unit]                (Tspeculative_load_t)\n"));
+  err (_(" * nb_bypass_memory                          [load_store_unit]                (uint32_t           )\n"));
+  err (_(" * size_write_queue                          [write_unit]                     (uint32_t           )\n"));
+  err (_(" * size_execute_queue                        [write_unit]                     (uint32_t           )\n"));
+  err (_(" * nb_bypass_write                           [write_unit]                     (uint32_t           )\n"));
+  err (_(" * nb_gpr_bank                                                                (uint32_t           )\n"));
+  err (_(" * nb_gpr_port_read_by_bank                                                   (uint32_t           )\n"));
+  err (_(" * nb_gpr_port_write_by_bank                                                  (uint32_t           )\n"));
+  err (_(" * nb_spr_bank                                                                (uint32_t           )\n"));
+  err (_(" * nb_spr_port_read_by_bank                                                   (uint32_t           )\n"));
+  err (_(" * nb_spr_port_write_by_bank                                                  (uint32_t           )\n"));
+  err (_(" * nb_general_register                       [nb_ooo_engine]                  (uint32_t           )\n"));
+  err (_(" * nb_special_register                       [nb_ooo_engine]                  (uint32_t           )\n"));
+  err (_(" * nb_inst_insert_rob                        [nb_ooo_engine]                  (uint32_t           )\n"));
+  err (_(" * nb_inst_retire_rob                        [nb_ooo_engine]                  (uint32_t           )\n"));
+  err (_(" * execution_unit_to_write_unit_priority                                      (Tpriority_t        )\n"));
+  err (_(" * execution_unit_to_write_unit_table_routing[nb_execute_unit][nb_write_unit] (bool               )\n"));
+  err (_(" * execution_unit_to_write_unit_table_thread [nb_write_unit][nb_thread]       (bool               )\n"));
+  err (_(" * read_unit_to_execution_unit_priority                                       (Tpriority_t        )\n"));
+  err (_(" * read_unit_to_execution_unit_table_routing [nb_read_unit][nb_execute_unit]  (bool               )\n"));
+  err (_(" * read_unit_to_execution_unit_table_thread  [nb_execute_unit][nb_thread]     (bool               )\n"));
+  err (_(" * nb_read_unit                                                                                     (uint32_t           )\n"));
+  err (_(" * nb_functionnal_unit                                                                              (uint32_t           )\n"));
+  err (_(" * nb_load_store_unit                                                                               (uint32_t           )\n"));
+  err (_(" * nb_write_unit                                                                                    (uint32_t           )\n"));
+  err (_(" * nb_context                                                                                       (uint32_t           )\n"));
+  err (_(" * nb_front_end                                                                                     (uint32_t           )\n"));
+  err (_(" * nb_ooo_engine                                                                                    (uint32_t           )\n"));
+  err (_(" * nb_packet                                                                                        (uint32_t           )\n"));
+  err (_(" * size_general_data                                                                                (uint32_t           )\n"));
+  err (_(" * size_special_data                                                                                (uint32_t           )\n"));
+  err (_(" * size_read_queue                           [nb_read_unit]                                         (uint32_t           )\n"));
+  err (_(" * size_reservation_station                  [nb_read_unit]                                         (uint32_t           )\n"));
+  err (_(" * nb_inst_retire                            [nb_read_unit]                                         (uint32_t           )\n"));
+  err (_(" * nb_inst_functionnal_unit                  [nb_functionnal_unit]                                  (uint32_t           )\n"));
+  err (_(" * size_store_queue                          [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * size_load_queue                           [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * size_speculative_access_queue             [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * nb_port_check                             [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * speculative_load                          [nb_load_store_unit]                                   (Tspeculative_load_t)\n"));
+  err (_(" * nb_bypass_memory                          [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * nb_cache_port                             [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * nb_inst_memory                            [nb_load_store_unit]                                   (uint32_t           )\n"));
+  err (_(" * size_write_queue                          [nb_write_unit]                                        (uint32_t           )\n"));
+  err (_(" * size_execute_queue                        [nb_write_unit]                                        (uint32_t           )\n"));
+  err (_(" * nb_bypass_write                           [nb_write_unit]                                        (uint32_t           )\n"));
+  err (_(" * nb_gpr_bank                                                                                      (uint32_t           )\n"));
+  err (_(" * nb_gpr_port_read_by_bank                                                                         (uint32_t           )\n"));
+  err (_(" * nb_gpr_port_write_by_bank                                                                        (uint32_t           )\n"));
+  err (_(" * nb_spr_bank                                                                                      (uint32_t           )\n"));
+  err (_(" * nb_spr_port_read_by_bank                                                                         (uint32_t           )\n"));
+  err (_(" * nb_spr_port_write_by_bank                                                                        (uint32_t           )\n"));
+  err (_(" * nb_general_register                       [nb_ooo_engine]                                        (uint32_t           )\n"));
+  err (_(" * nb_special_register                       [nb_ooo_engine]                                        (uint32_t           )\n"));
+  err (_(" * nb_inst_insert_rob                        [nb_ooo_engine]                                        (uint32_t           )\n"));
+  err (_(" * nb_inst_retire_rob                        [nb_ooo_engine]                                        (uint32_t           )\n"));
+  err (_(" * execution_unit_to_write_unit_priority                                                            (Tpriority_t        )\n"));
+  err (_(" * execution_unit_to_write_unit_table_routing[nb_execute_unit][nb_execute_unit_port][nb_write_unit] (bool               )\n"));
+  err (_(" * execution_unit_to_write_unit_table_thread [nb_write_unit][nb_thread]                             (bool               )\n"));
+  err (_(" * read_unit_to_execution_unit_priority                                                             (Tpriority_t        )\n"));
+  err (_(" * read_unit_to_execution_unit_table_routing [nb_read_unit][nb_execute_unit][nb_execute_unit_port]  (bool               )\n"));
+  err (_(" * read_unit_to_execution_unit_table_thread  [nb_execute_unit][nb_thread]                           (bool               )\n"));
+  err (_(" * is_load_store_unit                        [nb_execute_unit]                                      (bool               )\n"));
+  err (_(" * translate_num_execute_unit                [nb_execute_unit]                                      (uint32_t           )\n"));
   exit (1);
 …
 #endif
+{
+  // Command
+  for (int32_t i=0; i<argc; ++i)
+    msg("%s ",argv[i]);
+  msg("\n");
   if (argc < 2+NB_PARAMS)
     usage (argc, argv);
 …
   int32_t nb_params = (2+NB_PARAMS+
 *nb_read_unit+
+*nb_load_store_unit+
+*nb_functionnal_unit+
+*nb_load_store_unit+
 *nb_write_unit+
 *nb_ooo_engine+
                        nb_execute_unit*nb_write_unit+
+//                     sum_execute_unit_port*nb_write_unit+
                        nb_write_unit*nb_thread+
+                       nb_read_unit*nb_execute_unit+
+                       nb_execute_unit*nb_thread);
+  if (argc != nb_params)
+    {
+      msg(_("Need %d parameters."),nb_params);
+      usage (argc, argv);
+    }
+//                     nb_read_unit*sum_execute_unit_port+
+                       nb_execute_unit*nb_thread+
+*nb_execute_unit);
+  if (argc <= nb_params)
+    usage (argc, argv);
   uint32_t            * size_read_queue          = new uint32_t [nb_read_unit];
   for (uint32_t i=0; i<nb_read_unit; i++)
 …
     nb_inst_retire [i] = atoi(argv[x++]);
+  uint32_t            * nb_inst_functionnal_unit = new uint32_t [nb_functionnal_unit];
+  for (uint32_t i=0; i<nb_functionnal_unit; i++)
+    nb_inst_functionnal_unit [i] = atoi(argv[x++]);
   uint32_t          * size_store_queue              = new uint32_t [nb_load_store_unit];
   for (uint32_t i=0; i<nb_load_store_unit; i++)
 …
   for (uint32_t i=0; i<nb_load_store_unit; i++)
     nb_bypass_memory              [i] = atoi(argv[x++]);
+  uint32_t          * nb_cache_port                 = new uint32_t [nb_load_store_unit];
+  for (uint32_t i=0; i<nb_load_store_unit; i++)
+    nb_cache_port                 [i] = atoi(argv[x++]);
+  uint32_t          * nb_inst_memory                = new uint32_t [nb_load_store_unit];
+  for (uint32_t i=0; i<nb_load_store_unit; i++)
+    nb_inst_memory                [i] = atoi(argv[x++]);
+  uint32_t sum_execute_unit_port = 0;
+  for (uint32_t i=0; i<nb_load_store_unit; i++)
+    sum_execute_unit_port += nb_inst_memory[i];
+  for (uint32_t i=0; i<nb_functionnal_unit; i++)
+    sum_execute_unit_port += nb_inst_functionnal_unit[i];
+  nb_params = (2+NB_PARAMS+
+*nb_read_unit+
+*nb_functionnal_unit+
+*nb_load_store_unit+
+*nb_write_unit+
+*nb_ooo_engine+
+               sum_execute_unit_port*nb_write_unit+
+               nb_write_unit*nb_thread+
+               nb_read_unit*sum_execute_unit_port+
+               nb_execute_unit*nb_thread+
+*nb_execute_unit);
+  if (argc != nb_params)
+    {
+      msg("nb_functionnal_unit   : %d\n",nb_functionnal_unit);
+      msg("nb_load_store_unit    : %d\n",nb_load_store_unit );
+      msg("sum_execute_unit_port : %d.\n",sum_execute_unit_port);
+      msg(_("Have %d parameters.\n"),argc     );
+      msg(_("Need %d parameters.\n"),nb_params);
+      usage (argc, argv);
+    }
   uint32_t * size_write_queue   = new uint32_t [nb_write_unit];
 …
   Tpriority_t execution_unit_to_write_unit_priority = fromString<Tpriority_t>(argv[x++]);
   bool ** execution_unit_to_write_unit_table_routing = new bool * [nb_execute_unit];
+  bool *** execution_unit_to_write_unit_table_routing = new bool ** [nb_execute_unit];
   for (uint32_t i=0; i<nb_execute_unit; i++)
+    {
+      execution_unit_to_write_unit_table_routing [i] = new bool [nb_write_unit];
+      for (uint32_t j=0; j<nb_write_unit; j++)
+        execution_unit_to_write_unit_table_routing [i][j] = atoi(argv[x++]);
+    }
+      uint32_t nb_execute_unit_port = (i<nb_load_store_unit)?nb_inst_memory[i]:nb_inst_functionnal_unit[i-nb_load_store_unit];
+      execution_unit_to_write_unit_table_routing [i] = new bool * [nb_execute_unit_port];
+      for (uint32_t j=0; j<nb_execute_unit_port; j++)
+        {
+          execution_unit_to_write_unit_table_routing [i][j] = new bool [nb_write_unit];
+          for (uint32_t k=0; k<nb_write_unit; k++)
+            execution_unit_to_write_unit_table_routing [i][j][k] = atoi(argv[x++]);
+        }
+    }
   bool ** execution_unit_to_write_unit_table_thread = new bool * [nb_write_unit];
   for (uint32_t i=0; i<nb_write_unit; i++)
 …
   Tpriority_t read_unit_to_execution_unit_priority  = fromString<Tpriority_t>(argv[x++]);
   bool ** read_unit_to_execution_unit_table_routing = new bool * [nb_read_unit];
+  bool *** read_unit_to_execution_unit_table_routing = new bool ** [nb_read_unit];
   for (uint32_t i=0; i<nb_read_unit; i++)
+    {
       read_unit_to_execution_unit_table_routing [i] = new bool [nb_execute_unit];
+      read_unit_to_execution_unit_table_routing [i] = new bool * [nb_execute_unit];
       for (uint32_t j=0; j<nb_execute_unit; j++)
+        read_unit_to_execution_unit_table_routing [i][j] = atoi(argv[x++]);
+    }
+        {
+          uint32_t nb_execute_unit_port = (j<nb_load_store_unit)?nb_inst_memory[j]:nb_inst_functionnal_unit[j-nb_load_store_unit];
+          read_unit_to_execution_unit_table_routing [i][j] = new bool [nb_execute_unit_port];
+          for (uint32_t k=0; k<nb_execute_unit_port; k++)
+            read_unit_to_execution_unit_table_routing [i][j][k] = atoi(argv[x++]);
+        }
+    }
   bool ** read_unit_to_execution_unit_table_thread = new bool * [nb_execute_unit];
   for (uint32_t i=0; i<nb_execute_unit; i++)
 …
         read_unit_to_execution_unit_table_thread [i][j] =  atoi(argv[x++]);
+    }
+  execute_timing_t *** timing = new execute_timing_t ** [nb_execute_unit];
+  bool * is_load_store_unit = new bool [nb_execute_unit];
+  for (uint32_t i=0; i<nb_execute_unit; i++)
+    is_load_store_unit [i] = fromString<bool>(argv[x++]);
+  uint32_t * translate_num_execute_unit = new uint32_t [nb_execute_unit];
+  for (uint32_t i=0; i<nb_execute_unit; i++)
+    translate_num_execute_unit [i] = fromString<uint32_t>(argv[x++]);
+  execute_timing_t *** timing = new execute_timing_t ** [nb_functionnal_unit];
   // alloc and reset timing array
   for (uint32_t i=0; i< nb_execute_unit; i++)
+  for (uint32_t i=0; i< nb_functionnal_unit; i++)
+    {
       timing [i] = new execute_timing_t * [MAX_TYPE];
 …
+    }
-  for (uint32_t i=0; i< nb_load_store_unit; i++)
-    for (uint32_t k=0; k< MAX_OPERATION; k++)
-      timing[i][TYPE_MEMORY][k]._delay = timing[i][TYPE_MEMORY][k]._latence = 1;
   for (uint32_t i=0; i< nb_functionnal_unit; i++)
     for (uint32_t j=0; j< MAX_TYPE; j++)
+      if (j != TYPE_MEMORY)
+        for (uint32_t k=0; k< MAX_OPERATION; k++)
+          timing[i+nb_load_store_unit][j][k]._delay = timing[i+nb_load_store_unit][j][k]._latence = 1;
+  morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t) = &(morpheo::behavioural::custom::default_get_custom_information);
+      {
+        if ( (j != TYPE_MEMORY) and
+             not ((i!=0) and ((j == TYPE_SPECIAL) or
+                              (j == TYPE_CUSTOM))))
+          for (uint32_t k=0; k< MAX_OPERATION; k++)
+            timing[i][j][k]._delay = timing[i][j][k]._latence = 1;
+      }
+  morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void) = &(morpheo::behavioural::custom::default_get_custom_information);
   try
 …
          size_reservation_station                      ,
          nb_inst_retire                                ,
+         nb_inst_functionnal_unit                      ,
          timing                                        ,
          get_custom_information                        ,
 …
          nb_port_check                                 ,
          speculative_load                              ,
          nb_bypass_memory                              ,
+         nb_cache_port                                 ,
+         nb_inst_memory                                ,
          size_write_queue                              ,
          size_execute_queue                            ,
 …
          read_unit_to_execution_unit_priority          ,
          read_unit_to_execution_unit_table_routing     ,
+         read_unit_to_execution_unit_table_thread      );
+      msg(_("%s"),param->print(1).c_str());
+         read_unit_to_execution_unit_table_thread      ,
+         is_load_store_unit                            , //[nb_execute_unit]
+         translate_num_execute_unit                    , //[nb_execute_unit]
+         true // is_toplevel
+         );
       test (name,param);
 …
   catch (morpheo::ErrorMorpheo & error)
+    {
       msg (_("<%s> : %s.\n"),name.c_str(), error.what ());
+      msg (_("%s\n"),error.what ());
       exit (EXIT_FAILURE);
+    }
   catch (...)
+    {
       err (_("<%s> : This test must generate a error.\n"),name.c_str());
+      err (_("This test must generate a error.\n"));
       exit (EXIT_FAILURE);
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/src/test.cpp

-              r82
+              r88
  */
 #define NB_ITERATION  1
+#define NB_ITERATION  128
 #define CYCLE_MAX     (128*NB_ITERATION)
 …
 #ifdef STATISTICS
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
+  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,CYCLE_MAX);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Execute_loop * _Execute_loop = new Execute_loop
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ,"out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ",Tcontrol_t        ,_param->_nb_write_unit);
   ALLOC1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_ADDRESS             ,"out_EXECUTE_LOOP_OUT_ADDRESS             ",Tgeneral_data_t   ,_param->_nb_write_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_VAL                       ,"out_DCACHE_REQ_VAL                       ",Tcontrol_t        ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL( in_DCACHE_REQ_ACK                       ," in_DCACHE_REQ_ACK                       ",Tcontrol_t        ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_CONTEXT_ID                ,"out_DCACHE_REQ_CONTEXT_ID                ",Tcontext_t        ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_PACKET_ID                 ,"out_DCACHE_REQ_PACKET_ID                 ",Tpacket_t         ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_ADDRESS                   ,"out_DCACHE_REQ_ADDRESS                   ",Tdcache_address_t ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_TYPE                      ,"out_DCACHE_REQ_TYPE                      ",Tdcache_type_t    ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_REQ_WDATA                     ,"out_DCACHE_REQ_WDATA                     ",Tdcache_data_t    ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_VAL                       ," in_DCACHE_RSP_VAL                       ",Tcontrol_t        ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL(out_DCACHE_RSP_ACK                       ,"out_DCACHE_RSP_ACK                       ",Tcontrol_t        ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_CONTEXT_ID                ," in_DCACHE_RSP_CONTEXT_ID                ",Tcontext_t        ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_PACKET_ID                 ," in_DCACHE_RSP_PACKET_ID                 ",Tpacket_t         ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_RDATA                     ," in_DCACHE_RSP_RDATA                     ",Tdcache_data_t    ,_param->_nb_load_store_unit);
+  ALLOC1_SC_SIGNAL( in_DCACHE_RSP_ERROR                     ," in_DCACHE_RSP_ERROR                     ",Tdcache_error_t   ,_param->_nb_load_store_unit);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_VAL                       ," in_INSERT_ROB_VAL                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL(out_INSERT_ROB_ACK                       ,"out_INSERT_ROB_ACK                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RD_USE                    ," in_INSERT_ROB_RD_USE                    ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RD_NUM_REG                ," in_INSERT_ROB_RD_NUM_REG                ",Tgeneral_address_t,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RE_USE                    ," in_INSERT_ROB_RE_USE                    ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RE_NUM_REG                ," in_INSERT_ROB_RE_NUM_REG                ",Tspecial_address_t,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_VAL                       ," in_RETIRE_ROB_VAL                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL(out_RETIRE_ROB_ACK                       ,"out_RETIRE_ROB_ACK                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_OLD_USE                ," in_RETIRE_ROB_RD_OLD_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_OLD_NUM_REG            ," in_RETIRE_ROB_RD_OLD_NUM_REG            ",Tgeneral_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_NEW_USE                ," in_RETIRE_ROB_RD_NEW_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_NEW_NUM_REG            ," in_RETIRE_ROB_RD_NEW_NUM_REG            ",Tgeneral_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_OLD_USE                ," in_RETIRE_ROB_RE_OLD_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_OLD_NUM_REG            ," in_RETIRE_ROB_RE_OLD_NUM_REG            ",Tspecial_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_NEW_USE                ," in_RETIRE_ROB_RE_NEW_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_NEW_NUM_REG            ," in_RETIRE_ROB_RE_NEW_NUM_REG            ",Tspecial_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  ALLOC1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_DATA                ,"out_EXECUTE_LOOP_OUT_DATA                ",Tgeneral_data_t   ,_param->_nb_write_unit);
+  ALLOC2_SC_SIGNAL(out_DCACHE_REQ_VAL                       ,"out_DCACHE_REQ_VAL                       ",Tcontrol_t        ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_DCACHE_REQ_ACK                       ," in_DCACHE_REQ_ACK                       ",Tcontrol_t        ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL(out_DCACHE_REQ_CONTEXT_ID                ,"out_DCACHE_REQ_CONTEXT_ID                ",Tcontext_t        ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL(out_DCACHE_REQ_PACKET_ID                 ,"out_DCACHE_REQ_PACKET_ID                 ",Tpacket_t         ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL(out_DCACHE_REQ_ADDRESS                   ,"out_DCACHE_REQ_ADDRESS                   ",Tdcache_address_t ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL(out_DCACHE_REQ_TYPE                      ,"out_DCACHE_REQ_TYPE                      ",Tdcache_type_t    ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL(out_DCACHE_REQ_WDATA                     ,"out_DCACHE_REQ_WDATA                     ",Tdcache_data_t    ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_DCACHE_RSP_VAL                       ," in_DCACHE_RSP_VAL                       ",Tcontrol_t        ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL(out_DCACHE_RSP_ACK                       ,"out_DCACHE_RSP_ACK                       ",Tcontrol_t        ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_DCACHE_RSP_CONTEXT_ID                ," in_DCACHE_RSP_CONTEXT_ID                ",Tcontext_t        ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_DCACHE_RSP_PACKET_ID                 ," in_DCACHE_RSP_PACKET_ID                 ",Tpacket_t         ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_DCACHE_RSP_RDATA                     ," in_DCACHE_RSP_RDATA                     ",Tdcache_data_t    ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_DCACHE_RSP_ERROR                     ," in_DCACHE_RSP_ERROR                     ",Tdcache_error_t   ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_VAL                       ," in_INSERT_ROB_VAL                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  ALLOC2_SC_SIGNAL(out_INSERT_ROB_ACK                       ,"out_INSERT_ROB_ACK                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RD_USE                    ," in_INSERT_ROB_RD_USE                    ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RD_NUM_REG                ," in_INSERT_ROB_RD_NUM_REG                ",Tgeneral_address_t,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RE_USE                    ," in_INSERT_ROB_RE_USE                    ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  ALLOC2_SC_SIGNAL( in_INSERT_ROB_RE_NUM_REG                ," in_INSERT_ROB_RE_NUM_REG                ",Tspecial_address_t,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_VAL                       ," in_RETIRE_ROB_VAL                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL(out_RETIRE_ROB_ACK                       ,"out_RETIRE_ROB_ACK                       ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_OLD_USE                ," in_RETIRE_ROB_RD_OLD_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_OLD_NUM_REG            ," in_RETIRE_ROB_RD_OLD_NUM_REG            ",Tgeneral_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_NEW_USE                ," in_RETIRE_ROB_RD_NEW_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RD_NEW_NUM_REG            ," in_RETIRE_ROB_RD_NEW_NUM_REG            ",Tgeneral_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_OLD_USE                ," in_RETIRE_ROB_RE_OLD_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_OLD_NUM_REG            ," in_RETIRE_ROB_RE_OLD_NUM_REG            ",Tspecial_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_NEW_USE                ," in_RETIRE_ROB_RE_NEW_USE                ",Tcontrol_t        ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   ALLOC2_SC_SIGNAL( in_RETIRE_ROB_RE_NEW_NUM_REG            ," in_RETIRE_ROB_RE_NEW_NUM_REG            ",Tspecial_address_t,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
   /********************************************************
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_EXECUTE_LOOP_IN_OOO_ENGINE_ID        ,_param->_nb_read_unit);
   if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr  )
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_EXECUTE_LOOP_IN_PACKET_ID            ,_param->_nb_read_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_EXECUTE_LOOP_IN_OPERATION            ,_param->_nb_read_unit);
 …
   if (_param->_have_port_ooo_engine_id)
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_EXECUTE_LOOP_OUT_OOO_ENGINE_ID       ,_param->_nb_write_unit);
   if (_param->_have_port_packet_id)
+  if (_param->_have_port_rob_ptr  )
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_EXECUTE_LOOP_OUT_PACKET_ID           ,_param->_nb_write_unit);
 //INSTANCE1_SC_SIGNAL(_Execute_loop,out_EXECUTE_LOOP_OUT_OPERATION           ,_param->_nb_write_unit);
 …
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ,_param->_nb_write_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_EXECUTE_LOOP_OUT_ADDRESS             ,_param->_nb_write_unit);
+  INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_VAL                       ,_param->_nb_load_store_unit);
+  INSTANCE1_SC_SIGNAL(_Execute_loop, in_DCACHE_REQ_ACK                       ,_param->_nb_load_store_unit);
+  INSTANCE1_SC_SIGNAL(_Execute_loop,out_EXECUTE_LOOP_OUT_DATA                ,_param->_nb_write_unit);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_VAL                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_DCACHE_REQ_ACK                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
   if (_param->_have_port_dcache_context_id)
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_CONTEXT_ID                ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_PACKET_ID                 ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_ADDRESS                   ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_TYPE                      ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_WDATA                     ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_VAL                       ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop,out_DCACHE_RSP_ACK                       ,_param->_nb_load_store_unit);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_CONTEXT_ID                ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_PACKET_ID                 ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_ADDRESS                   ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_TYPE                      ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_REQ_WDATA                     ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_VAL                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_DCACHE_RSP_ACK                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
   if (_param->_have_port_dcache_context_id)
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_CONTEXT_ID                ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_PACKET_ID                 ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_RDATA                     ,_param->_nb_load_store_unit);
   INSTANCE1_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_ERROR                     ,_param->_nb_load_store_unit);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_VAL                       ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop,out_INSERT_ROB_ACK                       ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RD_USE                    ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RD_NUM_REG                ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RE_USE                    ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RE_NUM_REG                ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_VAL                       ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop,out_RETIRE_ROB_ACK                       ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_OLD_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_OLD_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_NEW_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_NEW_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_OLD_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_OLD_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_NEW_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_NEW_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_CONTEXT_ID                ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_PACKET_ID                 ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_RDATA                     ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_DCACHE_RSP_ERROR                     ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_VAL                       ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop,out_INSERT_ROB_ACK                       ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RD_USE                    ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RD_NUM_REG                ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RE_USE                    ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  INSTANCE2_SC_SIGNAL(_Execute_loop, in_INSERT_ROB_RE_NUM_REG                ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_VAL                       ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop,out_RETIRE_ROB_ACK                       ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_OLD_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_OLD_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_NEW_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RD_NEW_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_OLD_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_OLD_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_NEW_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   INSTANCE2_SC_SIGNAL(_Execute_loop, in_RETIRE_ROB_RE_NEW_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
   delete in_NRESET;
+  delete []  in_EXECUTE_LOOP_IN_VAL                  ;
+  delete [] out_EXECUTE_LOOP_IN_ACK                  ;
+  delete []  in_EXECUTE_LOOP_IN_CONTEXT_ID           ;
+  delete []  in_EXECUTE_LOOP_IN_FRONT_END_ID         ;
+  delete []  in_EXECUTE_LOOP_IN_OOO_ENGINE_ID        ;
+  delete []  in_EXECUTE_LOOP_IN_PACKET_ID            ;
+  delete []  in_EXECUTE_LOOP_IN_OPERATION            ;
+  delete []  in_EXECUTE_LOOP_IN_TYPE                 ;
+  delete []  in_EXECUTE_LOOP_IN_STORE_QUEUE_PTR_WRITE;
+  delete []  in_EXECUTE_LOOP_IN_LOAD_QUEUE_PTR_WRITE ;
+  delete []  in_EXECUTE_LOOP_IN_HAS_IMMEDIAT         ;
+  delete []  in_EXECUTE_LOOP_IN_IMMEDIAT             ;
+  delete []  in_EXECUTE_LOOP_IN_READ_RA              ;
+  delete []  in_EXECUTE_LOOP_IN_NUM_REG_RA           ;
+  delete []  in_EXECUTE_LOOP_IN_READ_RB              ;
+  delete []  in_EXECUTE_LOOP_IN_NUM_REG_RB           ;
+  delete []  in_EXECUTE_LOOP_IN_READ_RC              ;
+  delete []  in_EXECUTE_LOOP_IN_NUM_REG_RC           ;
+  delete []  in_EXECUTE_LOOP_IN_WRITE_RD             ;
+  delete []  in_EXECUTE_LOOP_IN_NUM_REG_RD           ;
+  delete []  in_EXECUTE_LOOP_IN_WRITE_RE             ;
+  delete []  in_EXECUTE_LOOP_IN_NUM_REG_RE           ;
+  delete [] out_EXECUTE_LOOP_OUT_VAL                 ;
+  delete []  in_EXECUTE_LOOP_OUT_ACK                 ;
+  delete [] out_EXECUTE_LOOP_OUT_CONTEXT_ID          ;
+  delete [] out_EXECUTE_LOOP_OUT_FRONT_END_ID        ;
+  delete [] out_EXECUTE_LOOP_OUT_OOO_ENGINE_ID       ;
+  delete [] out_EXECUTE_LOOP_OUT_PACKET_ID           ;
+//delete [] out_EXECUTE_LOOP_OUT_OPERATION           ;
+//delete [] out_EXECUTE_LOOP_OUT_TYPE                ;
+  delete [] out_EXECUTE_LOOP_OUT_FLAGS               ;
+  delete [] out_EXECUTE_LOOP_OUT_EXCEPTION           ;
+  delete [] out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ;
+  delete [] out_EXECUTE_LOOP_OUT_ADDRESS             ;
+  delete [] out_DCACHE_REQ_VAL                       ;
+  delete []  in_DCACHE_REQ_ACK                       ;
+  delete [] out_DCACHE_REQ_CONTEXT_ID                ;
+  delete [] out_DCACHE_REQ_PACKET_ID                 ;
+  delete [] out_DCACHE_REQ_ADDRESS                   ;
+  delete [] out_DCACHE_REQ_TYPE                      ;
+  delete [] out_DCACHE_REQ_WDATA                     ;
+  delete []  in_DCACHE_RSP_VAL                       ;
+  delete [] out_DCACHE_RSP_ACK                       ;
+  delete []  in_DCACHE_RSP_CONTEXT_ID                ;
+  delete []  in_DCACHE_RSP_PACKET_ID                 ;
+  delete []  in_DCACHE_RSP_RDATA                     ;
+  delete []  in_DCACHE_RSP_ERROR                     ;
+  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                ;
+  delete []  in_RETIRE_ROB_VAL                       ;
+  delete [] out_RETIRE_ROB_ACK                       ;
+  delete []  in_RETIRE_ROB_RD_OLD_USE                ;
+  delete []  in_RETIRE_ROB_RD_OLD_NUM_REG            ;
+  delete []  in_RETIRE_ROB_RD_NEW_USE                ;
+  delete []  in_RETIRE_ROB_RD_NEW_NUM_REG            ;
+  delete []  in_RETIRE_ROB_RE_OLD_USE                ;
+  delete []  in_RETIRE_ROB_RE_OLD_NUM_REG            ;
+  delete []  in_RETIRE_ROB_RE_NEW_USE                ;
+  delete []  in_RETIRE_ROB_RE_NEW_NUM_REG            ;
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_VAL                  ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_IN_ACK                  ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_CONTEXT_ID           ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_FRONT_END_ID         ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_OOO_ENGINE_ID        ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_PACKET_ID            ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_OPERATION            ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_TYPE                 ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_HAS_IMMEDIAT         ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_IMMEDIAT             ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_READ_RA              ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RA           ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_READ_RB              ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RB           ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_READ_RC              ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RC           ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_WRITE_RD             ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RD           ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_WRITE_RE             ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RE           ,_param->_nb_read_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_VAL                 ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL( in_EXECUTE_LOOP_OUT_ACK                 ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_CONTEXT_ID          ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_FRONT_END_ID        ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_OOO_ENGINE_ID       ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_PACKET_ID           ,_param->_nb_write_unit);
+//DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_OPERATION           ,_param->_nb_write_unit);
+//DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_TYPE                ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_FLAGS               ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_EXCEPTION           ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_ADDRESS             ,_param->_nb_write_unit);
+  DELETE1_SC_SIGNAL(out_EXECUTE_LOOP_OUT_DATA                ,_param->_nb_write_unit);
+  DELETE2_SC_SIGNAL(out_DCACHE_REQ_VAL                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_DCACHE_REQ_ACK                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL(out_DCACHE_REQ_CONTEXT_ID                ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL(out_DCACHE_REQ_PACKET_ID                 ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL(out_DCACHE_REQ_ADDRESS                   ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL(out_DCACHE_REQ_TYPE                      ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL(out_DCACHE_REQ_WDATA                     ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_DCACHE_RSP_VAL                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL(out_DCACHE_RSP_ACK                       ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_DCACHE_RSP_CONTEXT_ID                ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_DCACHE_RSP_PACKET_ID                 ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_DCACHE_RSP_RDATA                     ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_DCACHE_RSP_ERROR                     ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
+  DELETE2_SC_SIGNAL( in_INSERT_ROB_VAL                       ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  DELETE2_SC_SIGNAL(out_INSERT_ROB_ACK                       ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  DELETE2_SC_SIGNAL( in_INSERT_ROB_RD_USE                    ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  DELETE2_SC_SIGNAL( in_INSERT_ROB_RD_NUM_REG                ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  DELETE2_SC_SIGNAL( in_INSERT_ROB_RE_USE                    ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+  DELETE2_SC_SIGNAL( in_INSERT_ROB_RE_NUM_REG                ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_VAL                       ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL(out_RETIRE_ROB_ACK                       ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RD_OLD_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RD_OLD_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RD_NEW_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RD_NEW_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RE_OLD_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RE_OLD_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RE_NEW_USE                ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//   DELETE2_SC_SIGNAL( in_RETIRE_ROB_RE_NEW_NUM_REG            ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Execute_loop.h

-              r82
+              r88
 #include "Behavioural/include/Usage.h"
+#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/include/Execute_loop_Glue.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Read_unit.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Functionnal_unit.h"
 …
   public    : SC_OUT(Tcontrol_t        )   ** out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ;//[nb_write_unit]
   public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_LOOP_OUT_ADDRESS             ;//[nb_write_unit]
+  public    : SC_OUT(Tgeneral_data_t   )   ** out_EXECUTE_LOOP_OUT_DATA                ;//[nb_write_unit]
     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t        )   ** out_DCACHE_REQ_VAL                       ;//[nb_load_store_queue]
   public    : SC_IN (Tcontrol_t        )   **  in_DCACHE_REQ_ACK                       ;//[nb_load_store_queue]
   public    : SC_OUT(Tcontext_t        )   ** out_DCACHE_REQ_CONTEXT_ID                ;//[nb_load_store_queue]
   public    : SC_OUT(Tpacket_t         )   ** out_DCACHE_REQ_PACKET_ID                 ;//[nb_load_store_queue]
   public    : SC_OUT(Tdcache_address_t )   ** out_DCACHE_REQ_ADDRESS                   ;//[nb_load_store_queue]
   public    : SC_OUT(Tdcache_type_t    )   ** out_DCACHE_REQ_TYPE                      ;//[nb_load_store_queue]
   public    : SC_OUT(Tdcache_data_t    )   ** out_DCACHE_REQ_WDATA                     ;//[nb_load_store_queue]
+  public    : SC_OUT(Tcontrol_t        )  *** out_DCACHE_REQ_VAL                       ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_IN (Tcontrol_t        )  ***  in_DCACHE_REQ_ACK                       ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_OUT(Tcontext_t        )  *** out_DCACHE_REQ_CONTEXT_ID                ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_OUT(Tpacket_t         )  *** out_DCACHE_REQ_PACKET_ID                 ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_OUT(Tdcache_address_t )  *** out_DCACHE_REQ_ADDRESS                   ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_OUT(Tdcache_type_t    )  *** out_DCACHE_REQ_TYPE                      ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_OUT(Tdcache_data_t    )  *** out_DCACHE_REQ_WDATA                     ;//[nb_load_store_queue][nb_cache_port]
     // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )   **  in_DCACHE_RSP_VAL                       ;//[nb_load_store_queue]
   public    : SC_OUT(Tcontrol_t        )   ** out_DCACHE_RSP_ACK                       ;//[nb_load_store_queue]
   public    : SC_IN (Tcontext_t        )   **  in_DCACHE_RSP_CONTEXT_ID                ;//[nb_load_store_queue]
   public    : SC_IN (Tpacket_t         )   **  in_DCACHE_RSP_PACKET_ID                 ;//[nb_load_store_queue]
   public    : SC_IN (Tdcache_data_t    )   **  in_DCACHE_RSP_RDATA                     ;//[nb_load_store_queue]
   public    : SC_IN (Tdcache_error_t   )   **  in_DCACHE_RSP_ERROR                     ;//[nb_load_store_queue]
+  public    : SC_IN (Tcontrol_t        )  ***  in_DCACHE_RSP_VAL                       ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_OUT(Tcontrol_t        )  *** out_DCACHE_RSP_ACK                       ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_IN (Tcontext_t        )  ***  in_DCACHE_RSP_CONTEXT_ID                ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_IN (Tpacket_t         )  ***  in_DCACHE_RSP_PACKET_ID                 ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_IN (Tdcache_data_t    )  ***  in_DCACHE_RSP_RDATA                     ;//[nb_load_store_queue][nb_cache_port]
+  public    : SC_IN (Tdcache_error_t   )  ***  in_DCACHE_RSP_ERROR                     ;//[nb_load_store_queue][nb_cache_port]
     // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_IN (Tspecial_address_t)  ***  in_INSERT_ROB_RE_NUM_REG                ;//[nb_ooo_engine][nb_inst_insert_rob]
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL                       ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK                       ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_OLD_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_NEW_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_OLD_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_VAL                       ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_OUT(Tcontrol_t        )  *** out_RETIRE_ROB_ACK                       ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_OLD_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_OLD_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RD_NEW_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tgeneral_address_t)  ***  in_RETIRE_ROB_RD_NEW_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_OLD_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_OLD_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tcontrol_t        )  ***  in_RETIRE_ROB_RE_NEW_USE                ;//[nb_ooo_engine][nb_inst_retire_rob]
+//   public    : SC_IN (Tspecial_address_t)  ***  in_RETIRE_ROB_RE_NEW_NUM_REG            ;//[nb_ooo_engine][nb_inst_retire_rob]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public : morpheo::behavioural::core::multi_execute_loop::execute_loop::execute_loop_glue::                                 Execute_loop_Glue             * _component_glue                        ;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::                        Read_unit                    ** _component_read_unit                   ;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Functionnal_unit             ** _component_functionnal_unit            ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Parameters.h

-              r81
+              r88
 #include "Behavioural/include/Parameters.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Types.h"
+#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue/include/Parameters.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/include/Parameters.h"
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/include/Parameters.h"
 …
   public : uint32_t              _nb_load_store_unit                            ;
   public : uint32_t              _nb_write_unit                                 ;
     // generic parameters
+    // generic parameters
   public : uint32_t              _nb_context                                    ;
   public : uint32_t              _nb_front_end                                  ;
   public : uint32_t              _nb_ooo_engine                                 ;
   public : uint32_t              _nb_packet                                     ;
+  public : uint32_t              _size_general_data                             ;
+  public : uint32_t              _size_special_data                             ;
+    // specific parameters
+    //  * read_unit
+  public : uint32_t            * _size_read_queue                               ; //[nb_read_unit]
+  public : uint32_t            * _size_reservation_station                      ; //[nb_read_unit]
+  public : uint32_t            * _nb_inst_retire                                ; //[nb_read_unit]
+  public : uint32_t            * _read_unit_nb_register_write                   ; //[nb_read_unit]
+  public : uint32_t            * _read_unit_nb_bypass_write                     ; //[nb_read_unit]
+  public : uint32_t            * _read_unit_nb_bypass_memory                    ; //[nb_read_unit]
+  public : bool               ** _link_read_unit_with_load_store_unit           ; //[nb_read_unit][nb_load_store_unit]
+  public : bool               ** _link_read_unit_with_write_unit                ; //[nb_read_unit][nb_write_unit]
+  public : bool               ** _link_read_unit_with_thread                    ; //[nb_read_unit][nb_thread]
+    //  * functionnal_unit
+  public : execute_timing_t  *** _timing                                        ; //[nb_execute_unit][nb_type][nb_operation]
+  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (uint32_t);
+//public : uint32_t              _size_general_data                             ;
+//public : uint32_t              _size_special_data                             ;
+    // specific parameters
+    //  * functionnal_unit
+  public : uint32_t            * _nb_inst_functionnal_unit                      ; //[nb_functionnal_unit]
+  public : execute_timing_t  *** _timing                                        ; //[nb_functionnal_unit][nb_type][nb_operation]
+  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void);
     //  * load_store_unit
   public : uint32_t            * _size_store_queue                              ; //[nb_load_store_unit]
 …
   public : Tspeculative_load_t * _speculative_load                              ; //[nb_load_store_unit]
   public : uint32_t            * _nb_bypass_memory                              ; //[nb_load_store_unit]
+    //  * write_unit
+  public : uint32_t            * _nb_cache_port                                 ; //[nb_load_store_unit]
+  public : uint32_t            * _nb_inst_memory                                ; //[nb_load_store_unit]
+    //  * read_unit
+  public : uint32_t            * _size_read_queue                               ; //[nb_read_unit]
+  public : uint32_t            * _size_reservation_station                      ; //[nb_read_unit]
+  public : uint32_t            * _nb_inst_retire                                ; //[nb_read_unit]
+  public : uint32_t            * _read_unit_nb_register_write                   ; //[nb_read_unit]
+  public : uint32_t            * _read_unit_nb_bypass_write                     ; //[nb_read_unit]
+  public : uint32_t            * _read_unit_nb_bypass_memory                    ; //[nb_read_unit]
+  public : bool              *** _link_read_unit_with_load_store_unit           ; //[nb_read_unit][nb_load_store_unit][nb_inst_memory]
+  public : bool               ** _link_read_unit_with_write_unit                ; //[nb_read_unit][nb_write_unit]
+  public : bool               ** _link_read_unit_with_thread                    ; //[nb_read_unit][nb_thread]
+    //  * write_unit
   public : uint32_t            * _size_write_queue                              ; //[nb_write_unit]
   public : uint32_t            * _size_execute_queue                            ; //[nb_write_unit]
   public : uint32_t            * _nb_bypass_write                               ; //[nb_write_unit]
     //  * register_unit
+    //  * register_unit
   public : uint32_t              _nb_gpr_read                                   ;
   public : uint32_t              _nb_gpr_write                                  ;
 …
     //  * network
   public : Tpriority_t           _execution_unit_to_write_unit_priority         ;
   public : bool               ** _execution_unit_to_write_unit_table_routing    ; //[nb_execute_unit][nb_write_unit]
+  public : bool              *** _execution_unit_to_write_unit_table_routing    ; //[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
   public : bool               ** _execution_unit_to_write_unit_table_thread     ; //[nb_write_unit][nb_thread]
   public : Tpriority_t           _read_unit_to_execution_unit_priority          ;
   public : bool               ** _read_unit_to_execution_unit_table_routing     ; //[nb_read_unit][nb_execute_unit]
+  public : bool              *** _read_unit_to_execution_unit_table_routing     ; //[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
   public : bool               ** _read_unit_to_execution_unit_table_execute_type; //[nb_execute_unit][nb_type]
   public : bool               ** _read_unit_to_execution_unit_table_thread      ; //[nb_execute_unit][nb_thread]
 …
   public : uint32_t              _nb_execute_unit              ;
+  public : uint32_t              _size_context_id              ;
+  public : uint32_t              _size_front_end_id            ;
+  public : uint32_t              _size_ooo_engine_id           ;
+  public : uint32_t              _size_packet_id               ;
+  public : bool                  _have_port_context_id         ;
+  public : bool                  _have_port_front_end_id       ;
+  public : bool                  _have_port_ooo_engine_id      ;
+  public : bool                  _have_port_packet_id          ;
+  public : bool                  _have_port_load_queue_ptr     ;
+  public : uint32_t            * _nb_execute_unit_port         ;
+//public : uint32_t              _size_context_id              ;
+//public : uint32_t              _size_front_end_id            ;
+//public : uint32_t              _size_ooo_engine_id           ;
+//public : uint32_t              _size_packet_id               ;
+//public : bool                  _have_port_context_id         ;
+//public : bool                  _have_port_front_end_id       ;
+//public : bool                  _have_port_ooo_engine_id      ;
+//public : bool                  _have_port_packet_id          ;
+//public : bool                  _have_port_load_queue_ptr     ;
   public : bool                  _have_port_dcache_context_id  ;
 …
   public : uint32_t              _max_size_load_queue    ;
   public : uint32_t              _size_general_register        ;
   public : uint32_t              _size_special_register        ;
+//public : uint32_t              _size_general_register        ;
+//public : uint32_t              _size_special_register        ;
   public : uint32_t              _max_size_dcache_context_id;
 …
   public : std::set<uint32_t>  * _set_read_unit_source_bypass_memory  ; //[nb_read_unit]
+  public : morpheo::behavioural::core::multi_execute_loop::execute_loop::execute_loop_glue::                                 Parameters  * _param_glue;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::                        Parameters ** _param_read_unit;
   public : morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters ** _param_functionnal_unit;
 …
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t              nb_read_unit                                  ,
+                        uint32_t              nb_functionnal_unit                           ,
+                        uint32_t              nb_load_store_unit                            ,
+                        uint32_t              nb_write_unit                                 ,
+                        uint32_t              nb_context                                    ,
+                        uint32_t              nb_front_end                                  ,
+                        uint32_t              nb_ooo_engine                                 ,
+                        uint32_t              nb_packet                                     ,
+                        uint32_t              size_general_data                             ,
+                        uint32_t              size_special_data                             ,
+                        uint32_t            * size_read_queue                               ,
+                        uint32_t            * size_reservation_station                      ,
+                        uint32_t            * nb_inst_retire                                ,
+                        execute_timing_t  *** timing                                        ,
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t),
+                        uint32_t            * size_store_queue                              ,
+                        uint32_t            * size_load_queue                               ,
+                        uint32_t            * size_speculative_access_queue                 ,
+                        uint32_t            * nb_port_check                                 ,
+                        Tspeculative_load_t * speculative_load                              ,
+                        uint32_t            * nb_bypass_memory                              ,
+                        uint32_t            * size_write_queue                              ,
+                        uint32_t            * size_execute_queue                            ,
+                        uint32_t            * nb_bypass_write                               ,
+                        uint32_t              nb_gpr_bank                                   ,
+                        uint32_t              nb_gpr_port_read_by_bank                      ,
+                        uint32_t              nb_gpr_port_write_by_bank                     ,
+                        uint32_t              nb_spr_bank                                   ,
+                        uint32_t              nb_spr_port_read_by_bank                      ,
+                        uint32_t              nb_spr_port_write_by_bank                     ,
+                        uint32_t            * nb_general_register                           ,
+                        uint32_t            * nb_special_register                           ,
+                        uint32_t            * nb_inst_insert_rob                            ,
+                        uint32_t            * nb_inst_retire_rob                            ,
+                        Tpriority_t           execution_unit_to_write_unit_priority         ,
+                        bool               ** execution_unit_to_write_unit_table_routing    ,
+                        bool               ** execution_unit_to_write_unit_table_thread     ,
+                        Tpriority_t           read_unit_to_execution_unit_priority          ,
+                        bool               ** read_unit_to_execution_unit_table_routing     ,
+                        bool               ** read_unit_to_execution_unit_table_thread
+                        );
+                        uint32_t              nb_functionnal_unit                           ,
+                        uint32_t              nb_load_store_unit                            ,
+                        uint32_t              nb_write_unit                                 ,
+                        uint32_t              nb_context                                    ,
+                        uint32_t              nb_front_end                                  ,
+                        uint32_t              nb_ooo_engine                                 ,
+                        uint32_t              nb_packet                                     ,
+                        uint32_t              size_general_data                             ,
+                        uint32_t              size_special_data                             ,
+                        uint32_t            * size_read_queue                               ,//[nb_read_unit]
+                        uint32_t            * size_reservation_station                      ,//[nb_read_unit]
+                        uint32_t            * nb_inst_retire                                ,//[nb_read_unit]
+                        uint32_t            * nb_inst_functionnal_unit                      ,//[nb_functionnal_unit]
+                        execute_timing_t  *** timing                                        ,//[nb_functionnal_unit][nb_type][nb_operation]
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                        uint32_t            * size_store_queue                              ,//[nb_load_store_unit]
+                        uint32_t            * size_load_queue                               ,//[nb_load_store_unit]
+                        uint32_t            * size_speculative_access_queue                 ,//[nb_load_store_unit]
+                        uint32_t            * nb_port_check                                 ,//[nb_load_store_unit]
+                        Tspeculative_load_t * speculative_load                              ,//[nb_load_store_unit]
+                        uint32_t            * nb_bypass_memory                              ,//[nb_load_store_unit]
+                        uint32_t            * nb_cache_port                                 ,//[nb_load_store_unit]
+                        uint32_t            * nb_inst_memory                                ,//[nb_load_store_unit]
+                        uint32_t            * size_write_queue                              ,//[nb_write_unit]
+                        uint32_t            * size_execute_queue                            ,//[nb_write_unit]
+                        uint32_t            * nb_bypass_write                               ,//[nb_write_unit]
+                        uint32_t              nb_gpr_bank                                   ,
+                        uint32_t              nb_gpr_port_read_by_bank                      ,
+                        uint32_t              nb_gpr_port_write_by_bank                     ,
+                        uint32_t              nb_spr_bank                                   ,
+                        uint32_t              nb_spr_port_read_by_bank                      ,
+                        uint32_t              nb_spr_port_write_by_bank                     ,
+                        uint32_t            * nb_general_register                           ,//[nb_ooo_engine]
+                        uint32_t            * nb_special_register                           ,//[nb_ooo_engine]
+                        uint32_t            * nb_inst_insert_rob                            ,//[nb_ooo_engine]
+                        uint32_t            * nb_inst_retire_rob                            ,//[nb_ooo_engine]
+                        Tpriority_t           execution_unit_to_write_unit_priority         ,
+                        bool              *** execution_unit_to_write_unit_table_routing    ,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+                        bool               ** execution_unit_to_write_unit_table_thread     ,//[nb_write_unit][nb_thread]
+                        Tpriority_t           read_unit_to_execution_unit_priority          ,
+                        bool              *** read_unit_to_execution_unit_table_routing     ,//[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
+                        bool               ** read_unit_to_execution_unit_table_thread      ,//[nb_execute_unit][nb_thread]
+                        bool                * is_load_store_unit                            ,//[nb_execute_unit]
+                        uint32_t            * translate_num_execute_unit                    ,//[nb_execute_unit]
+                        bool                  is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
+  public : ~Parameters () ;
+  public : ~Parameters (void) ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string   print      (uint32_t depth);
   public : friend std::ostream& operator<< (std::ostream& output_stream,
                                             morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters & x);
+  public :        std::string     print      (uint32_t depth);
+  public : friend std::ostream&   operator<< (std::ostream& output_stream,
+                                              morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters & x);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop.cpp

-              r81
+              r88
     log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
+#if DEBUG_Execute_loop == true
+    log_printf(INFO,Execute_loop,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Execute_loop,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Execute_loop,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Execute_loop,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Execute_loop,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_allocation.cpp

-              r82
+              r88
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t        ,_param->_size_front_end_id);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_OOO_ENGINE_ID        ,"ooo_engine_id"        ,Tcontext_t        ,_param->_size_ooo_engine_id);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_packet_id);
+       ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_PACKET_ID            ,"packet_id"            ,Tpacket_t         ,_param->_size_rob_ptr  );
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_OPERATION            ,"operation"            ,Toperation_t      ,_param->_size_operation);
        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->_max_size_store_queue);
+       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->_max_size_load_queue);
+       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);
        ALLOC1_SIGNAL_IN ( in_EXECUTE_LOOP_IN_IMMEDIAT             ,"immediat"             ,Tgeneral_data_t   ,_param->_size_general_data);
 …
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_FRONT_END_ID ,"front_end_id" ,Tcontext_t     ,_param->_size_front_end_id);
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_OOO_ENGINE_ID,"ooo_engine_id",Tcontext_t     ,_param->_size_ooo_engine_id);
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_packet_id);
+       ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_PACKET_ID    ,"packet_id"    ,Tpacket_t      ,_param->_size_rob_ptr  );
 //     ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_OPERATION    ,"operation"    ,Toperation_t   ,_param->_size_operation);
 //     ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_TYPE         ,"type"         ,Ttype_t        ,_param->_size_type);
 …
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_NO_SEQUENCE  ,"no_sequence"  ,Tcontrol_t     ,1);
        ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_general_data);
+       ALLOC1_SIGNAL_OUT(out_EXECUTE_LOOP_OUT_DATA         ,"data"         ,Tgeneral_data_t,_param->_size_general_data);
+     }
     // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("dcache_req",OUT, NORTH, "Data cache port : request", _param->_nb_load_store_unit);
        ALLOC1_VALACK_OUT(out_DCACHE_REQ_VAL,VAL);
        ALLOC1_VALACK_IN ( in_DCACHE_REQ_ACK,ACK);
        ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_CONTEXT_ID,"context_id",Tcontext_t       ,_param->_max_size_dcache_context_id);
        ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_PACKET_ID ,"packet_id" ,Tpacket_t        ,_param->_max_size_dcache_packet_id );
        ALLOC1_SIGNAL_OUT(out_DCACHE_REQ_ADDRESS   ,"address"   ,Tdcache_address_t,_param->_size_general_data);
        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);
+       ALLOC2_INTERFACE("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]);
+       _ALLOC2_VALACK_IN ( in_DCACHE_REQ_ACK,ACK, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_CONTEXT_ID,"context_id",Tcontext_t       ,_param->_max_size_dcache_context_id, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_PACKET_ID ,"packet_id" ,Tpacket_t        ,_param->_max_size_dcache_packet_id , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _ALLOC2_SIGNAL_OUT(out_DCACHE_REQ_ADDRESS   ,"address"   ,Tdcache_address_t,_param->_size_general_data         , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _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]);
+     }
     // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC1_INTERFACE("dcache_rsp",IN, NORTH, "Data cache port : respons", _param->_nb_load_store_unit);
        ALLOC1_VALACK_IN ( in_DCACHE_RSP_VAL,VAL);
        ALLOC1_VALACK_OUT(out_DCACHE_RSP_ACK,ACK);
        ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_CONTEXT_ID,"context_id",Tcontext_t     ,_param->_max_size_dcache_context_id);
        ALLOC1_SIGNAL_IN ( in_DCACHE_RSP_PACKET_ID ,"packet_id" ,Tpacket_t      ,_param->_max_size_dcache_packet_id);
        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);
+       ALLOC2_INTERFACE("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]);
+       _ALLOC2_VALACK_OUT(out_DCACHE_RSP_ACK,ACK, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_DCACHE_RSP_CONTEXT_ID,"context_id",Tcontext_t     ,_param->_max_size_dcache_context_id, _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _ALLOC2_SIGNAL_IN ( in_DCACHE_RSP_PACKET_ID ,"packet_id" ,Tpacket_t      ,_param->_max_size_dcache_packet_id , _param->_nb_load_store_unit, _param->_nb_cache_port[it1]);
+       _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]);
+     }
     // ~~~~~[ 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[alloc_interface_it1]);
        _ALLOC2_VALACK_IN ( in_INSERT_ROB_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
        _ALLOC2_VALACK_OUT(out_INSERT_ROB_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_USE    ,"rd_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RD_NUM_REG,"rd_num_reg",Tgeneral_address_t,_param->_size_general_register,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_INSERT_ROB_RE_USE    ,"re_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[alloc_signal_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[alloc_signal_it1]);
+       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_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_general_register,_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_special_register,_param->_nb_ooo_engine,_param->_nb_inst_insert_rob[it1]);
+     }
     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
        ALLOC2_INTERFACE("retire_rob",IN, EAST, "Rename's stage : retire a new instruction in the Re Order Buffer",_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_interface_it1]);
        _ALLOC2_VALACK_IN ( in_RETIRE_ROB_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_VALACK_OUT(out_RETIRE_ROB_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_OLD_USE    ,"rd_old_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_OLD_NUM_REG,"rd_old_num_reg",Tgeneral_address_t,_param->_size_general_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_NEW_USE    ,"rd_new_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_NEW_NUM_REG,"rd_new_num_reg",Tgeneral_address_t,_param->_size_general_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_OLD_USE    ,"re_old_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_OLD_NUM_REG,"re_old_num_reg",Tspecial_address_t,_param->_size_special_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_NEW_USE    ,"re_new_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_NEW_NUM_REG,"re_new_num_reg",Tspecial_address_t,_param->_size_special_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[alloc_signal_it1]);
+     }
+//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//      {
+//        ALLOC2_INTERFACE("retire_rob",IN, EAST, "Rename's stage : retire a new instruction in the Re Order Buffer",_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_VALACK_IN ( in_RETIRE_ROB_VAL,VAL,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_VALACK_OUT(out_RETIRE_ROB_ACK,ACK,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_OLD_USE    ,"rd_old_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_OLD_NUM_REG,"rd_old_num_reg",Tgeneral_address_t,_param->_size_general_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_NEW_USE    ,"rd_new_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RD_NEW_NUM_REG,"rd_new_num_reg",Tgeneral_address_t,_param->_size_general_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_OLD_USE    ,"re_old_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_OLD_NUM_REG,"re_old_num_reg",Tspecial_address_t,_param->_size_special_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_NEW_USE    ,"re_new_use"    ,Tcontrol_t        ,1                             ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//        _ALLOC2_SIGNAL_IN ( in_RETIRE_ROB_RE_NEW_NUM_REG,"re_new_num_reg",Tspecial_address_t,_param->_size_special_register,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1]);
+//      }
      // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      std::string name;
+     {
+       name = _name+"_glue";
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
+       _component_glue = new morpheo::behavioural::core::multi_execute_loop::execute_loop::execute_loop_glue::Execute_loop_Glue
+         (name.c_str()
+#ifdef STATISTICS
+          ,param_statistics
+#endif
+          ,_param->_param_glue
+          ,_usage);
+       _component->set_component (_component_glue->_component
+#ifdef POSITION
+                                  , 50, 50, 10, 10
+#endif
+                                  );
+     }
      _component_read_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Read_unit * [_param->_nb_read_unit];
 …
+       {
          name = _name+"_read_unit_"+toString(i);
          std::cout << "Create   : " << name << std::endl;
+         log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
          _component_read_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Read_unit
 …
+       {
          name = _name+"_functionnal_unit_"+toString(i);
          std::cout << "Create   : " << name << std::endl;
+         log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
          _component_functionnal_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Functionnal_unit
 …
+       {
          name = _name+"_load_store_unit_"+toString(i);
          std::cout << "Create   : " << name << std::endl;
+         log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
          _component_load_store_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Load_store_unit
 …
+       {
          name = _name+"_write_unit_"+toString(i);
          std::cout << "Create   : " << name << std::endl;
+         log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
          _component_write_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Write_unit
 …
+     {
        name = _name+"_read_unit_to_execution_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_read_unit_to_execution_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Read_unit_to_Execution_unit
 …
+     {
        name = _name+"_execution_unit_to_write_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_execution_unit_to_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Execution_unit_to_Write_unit
 …
+     {
        name = _name+"_register_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_register_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::Register_unit
 …
      // ~~~~~[ Instanciation ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      std::string src,dest;
+     // ===================================================================
+     // =====[ GLUE ]======================================================
+     // ===================================================================
+     {
+       src = _name+"_glue";
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+       {
+         dest = _name;
+#ifdef POSITION
+         _component->interface_map (src ,"",
+                                    dest,"");
+#endif
+         PORT_MAP(_component ,src , "in_CLOCK" ,dest, "in_CLOCK");
+         PORT_MAP(_component ,src , "in_NRESET",dest, "in_NRESET");
+       }
+       for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
+         {
+           {
+             dest = _name+"_write_unit_"+toString(i);
+#ifdef POSITION
+             _component->interface_map (src ,"gpr_write_write_unit_"+toString(i),
+                                        dest,"gpr_write");
+#endif
+             //  in_GPR_WRITE_WRITE_UNIT_VAL
+             // out_GPR_WRITE_WRITE_UNIT_ACK
+             //  in_GPR_WRITE_WRITE_UNIT_OOO_ENGINE_ID
+             //  in_GPR_WRITE_WRITE_UNIT_NUM_REG
+             //  in_GPR_WRITE_WRITE_UNIT_DATA
+           }
+           {
+             dest = _name+"_register_unit";
+#ifdef POSITION
+             _component->interface_map (src ,"gpr_write_register_file_"+toString(i),
+                                        dest,"gpr_write_"+toString(i));
+#endif
+             // out_GPR_WRITE_REGISTER_FILE_VAL
+             //  in_GPR_WRITE_REGISTER_FILE_ACK
+             // out_GPR_WRITE_REGISTER_FILE_OOO_ENGINE_ID
+             // out_GPR_WRITE_REGISTER_FILE_NUM_REG
+             // out_GPR_WRITE_REGISTER_FILE_DATA
+           }
+           {
+             dest = _name+"_read_unit_0";
+#ifdef POSITION
+             _component->interface_map (src ,"gpr_write_read_unit_"+toString(i),
+                                        dest,"gpr_write");
+#endif
+             // out_GPR_WRITE_READ_UNIT_VAL
+             // out_GPR_WRITE_READ_UNIT_OOO_ENGINE_ID
+             // out_GPR_WRITE_READ_UNIT_NUM_REG
+             // out_GPR_WRITE_READ_UNIT_DATA
+           }
+         }
+       for (uint32_t i=0; i<_param->_nb_spr_write; i++)
+         {
+           {
+             dest = _name+"_write_unit_"+toString(i);
+#ifdef POSITION
+             _component->interface_map (src ,"spr_write_write_unit_"+toString(i),
+                                        dest,"spr_write");
+#endif
+             //  in_SPR_WRITE_WRITE_UNIT_VAL
+             // out_SPR_WRITE_WRITE_UNIT_ACK
+             //  in_SPR_WRITE_WRITE_UNIT_OOO_ENGINE_ID
+             //  in_SPR_WRITE_WRITE_UNIT_NUM_REG
+             //  in_SPR_WRITE_WRITE_UNIT_DATA
+           }
+           {
+             dest = _name+"_register_unit";
+#ifdef POSITION
+             _component->interface_map (src ,"spr_write_register_file_"+toString(i),
+                                        dest,"spr_write_"+toString(i));
+#endif
+             // out_SPR_WRITE_REGISTER_FILE_VAL
+             //  in_SPR_WRITE_REGISTER_FILE_ACK
+             // out_SPR_WRITE_REGISTER_FILE_OOO_ENGINE_ID
+             // out_SPR_WRITE_REGISTER_FILE_NUM_REG
+             // out_SPR_WRITE_REGISTER_FILE_DATA
+           }
+           {
+             dest = _name+"_read_unit_0";
+#ifdef POSITION
+             _component->interface_map (src ,"spr_write_read_unit_"+toString(i),
+                                        dest,"spr_write");
+#endif
+             // out_SPR_WRITE_READ_UNIT_VAL
+             // out_SPR_WRITE_READ_UNIT_OOO_ENGINE_ID
+             // out_SPR_WRITE_READ_UNIT_NUM_REG
+             // out_SPR_WRITE_READ_UNIT_DATA
+           }
+         }
+     }
      // ===================================================================
 …
+         {
            src = _name+"_read_unit_"+toString(i);
            std::cout << "Instance : " << src << std::endl;
+           log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+           {
 …
              if (_param->_have_port_ooo_engine_id)
              PORT_MAP(_component ,src , "in_READ_UNIT_IN_OOO_ENGINE_ID"        ,dest , "in_EXECUTE_LOOP_IN_"+toString(i)+"_OOO_ENGINE_ID"        );
              if (_param->_have_port_packet_id)
+             if (_param->_have_port_rob_ptr  )
              PORT_MAP(_component ,src , "in_READ_UNIT_IN_PACKET_ID"            ,dest , "in_EXECUTE_LOOP_IN_"+toString(i)+"_PACKET_ID"            );
              PORT_MAP(_component ,src , "in_READ_UNIT_IN_OPERATION"            ,dest , "in_EXECUTE_LOOP_IN_"+toString(i)+"_OPERATION"            );
 …
 #ifdef POSITION
                _component->interface_map (src ,"read_unit_"+toString(i),
+               _component->interface_map (src ,"read_unit_"+toString(j),
                                           dest,"read_unit_"+toString(it_read_unit_out));
 #endif
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_VAL"                  ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_VAL"                  );
                PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(i               )+"_ACK"                  ,
                                     dest,"out_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_ACK"                  );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_VAL"                  ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_VAL"                  );
+               COMPONENT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(j               )+"_ACK"                  ,
+                                         dest,"out_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_ACK"                  );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_CONTEXT_ID"           ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_CONTEXT_ID"           );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_CONTEXT_ID"           ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_CONTEXT_ID"           );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_FRONT_END_ID"         ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_FRONT_END_ID"         );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_FRONT_END_ID"         ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_FRONT_END_ID"         );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_OOO_ENGINE_ID"        ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_OOO_ENGINE_ID"        );
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_PACKET_ID"            ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_PACKET_ID"            );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_OPERATION"            ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_OPERATION"            );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_TYPE"                 ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_TYPE"                 );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_STORE_QUEUE_PTR_WRITE",
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_STORE_QUEUE_PTR_WRITE");
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_OOO_ENGINE_ID"        ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_OOO_ENGINE_ID"        );
+               if (_param->_have_port_rob_ptr  )
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_PACKET_ID"            ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_PACKET_ID"            );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_OPERATION"            ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_OPERATION"            );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_TYPE"                 ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_TYPE"                 );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_STORE_QUEUE_PTR_WRITE",
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_STORE_QUEUE_PTR_WRITE");
                if (_param->_have_port_load_queue_ptr)
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_LOAD_QUEUE_PTR_WRITE" ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_LOAD_QUEUE_PTR_WRITE" );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_HAS_IMMEDIAT"         ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_HAS_IMMEDIAT"         );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_IMMEDIAT"             ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_IMMEDIAT"             );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_DATA_RA"              ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RA"              );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_DATA_RB"              ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RB"              );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_DATA_RC"              ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RC"              );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_WRITE_RD"             ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_WRITE_RD"             );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_NUM_REG_RD"           ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_NUM_REG_RD"           );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_WRITE_RE"             ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_WRITE_RE"             );
                PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(i               )+"_NUM_REG_RE"           ,
                                     dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_NUM_REG_RE"           );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_LOAD_QUEUE_PTR_WRITE" ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_LOAD_QUEUE_PTR_WRITE" );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_HAS_IMMEDIAT"         ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_HAS_IMMEDIAT"         );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_IMMEDIAT"             ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_IMMEDIAT"             );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RA"              ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_DATA_RA"              );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RB"              ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_DATA_RB"              );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RC"              ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_DATA_RC"              );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_WRITE_RD"             ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_WRITE_RD"             );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_NUM_REG_RD"           ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_NUM_REG_RD"           );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_WRITE_RE"             ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_WRITE_RE"             );
+               COMPONENT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(j               )+"_NUM_REG_RE"           ,
+                                         dest, "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_"+toString(j)+"_NUM_REG_RE"           );
-             it_read_unit_out ++;
+           }
+           it_read_unit_out ++;
            // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
                                         dest,"gpr_read_"+toString(2*i+1));
 #endif
              PORT_MAP(_component ,src ,"out_GPR_READ_0_VAL"          , dest, "in_GPR_READ_"+toString(2*i  )+"_VAL"          );
              PORT_MAP(_component ,src , "in_GPR_READ_0_ACK"          , dest,"out_GPR_READ_"+toString(2*i  )+"_ACK"          );
+             COMPONENT_MAP(_component ,src ,"out_GPR_READ_0_VAL"          , dest, "in_GPR_READ_"+toString(2*i  )+"_VAL"          );
+             COMPONENT_MAP(_component ,src , "in_GPR_READ_0_ACK"          , dest,"out_GPR_READ_"+toString(2*i  )+"_ACK"          );
              if (_param->_have_port_ooo_engine_id)
              PORT_MAP(_component ,src ,"out_GPR_READ_0_OOO_ENGINE_ID", dest, "in_GPR_READ_"+toString(2*i  )+"_OOO_ENGINE_ID");
              PORT_MAP(_component ,src ,"out_GPR_READ_0_NUM_REG"      , dest, "in_GPR_READ_"+toString(2*i  )+"_NUM_REG"      );
              PORT_MAP(_component ,src , "in_GPR_READ_0_DATA"         , dest,"out_GPR_READ_"+toString(2*i  )+"_DATA"         );
              PORT_MAP(_component ,src , "in_GPR_READ_0_DATA_VAL"     , dest,"out_GPR_READ_"+toString(2*i  )+"_DATA_VAL"     );
              PORT_MAP(_component ,src ,"out_GPR_READ_1_VAL"          , dest, "in_GPR_READ_"+toString(2*i+1)+"_VAL"          );
              PORT_MAP(_component ,src , "in_GPR_READ_1_ACK"          , dest,"out_GPR_READ_"+toString(2*i+1)+"_ACK"          );
+             COMPONENT_MAP(_component ,src ,"out_GPR_READ_0_OOO_ENGINE_ID", dest, "in_GPR_READ_"+toString(2*i  )+"_OOO_ENGINE_ID");
+             COMPONENT_MAP(_component ,src ,"out_GPR_READ_0_NUM_REG"      , dest, "in_GPR_READ_"+toString(2*i  )+"_NUM_REG"      );
+             COMPONENT_MAP(_component ,src , "in_GPR_READ_0_DATA"         , dest,"out_GPR_READ_"+toString(2*i  )+"_DATA"         );
+             COMPONENT_MAP(_component ,src , "in_GPR_READ_0_DATA_VAL"     , dest,"out_GPR_READ_"+toString(2*i  )+"_DATA_VAL"     );
+             COMPONENT_MAP(_component ,src ,"out_GPR_READ_1_VAL"          , dest, "in_GPR_READ_"+toString(2*i+1)+"_VAL"          );
+             COMPONENT_MAP(_component ,src , "in_GPR_READ_1_ACK"          , dest,"out_GPR_READ_"+toString(2*i+1)+"_ACK"          );
              if (_param->_have_port_ooo_engine_id)
              PORT_MAP(_component ,src ,"out_GPR_READ_1_OOO_ENGINE_ID", dest, "in_GPR_READ_"+toString(2*i+1)+"_OOO_ENGINE_ID");
              PORT_MAP(_component ,src ,"out_GPR_READ_1_NUM_REG"      , dest, "in_GPR_READ_"+toString(2*i+1)+"_NUM_REG"      );
              PORT_MAP(_component ,src , "in_GPR_READ_1_DATA"         , dest,"out_GPR_READ_"+toString(2*i+1)+"_DATA"         );
              PORT_MAP(_component ,src , "in_GPR_READ_1_DATA_VAL"     , dest,"out_GPR_READ_"+toString(2*i+1)+"_DATA_VAL"     );
+             COMPONENT_MAP(_component ,src ,"out_GPR_READ_1_OOO_ENGINE_ID", dest, "in_GPR_READ_"+toString(2*i+1)+"_OOO_ENGINE_ID");
+             COMPONENT_MAP(_component ,src ,"out_GPR_READ_1_NUM_REG"      , dest, "in_GPR_READ_"+toString(2*i+1)+"_NUM_REG"      );
+             COMPONENT_MAP(_component ,src , "in_GPR_READ_1_DATA"         , dest,"out_GPR_READ_"+toString(2*i+1)+"_DATA"         );
+             COMPONENT_MAP(_component ,src , "in_GPR_READ_1_DATA_VAL"     , dest,"out_GPR_READ_"+toString(2*i+1)+"_DATA_VAL"     );
+           }
 …
 #ifdef POSITION
              _component->interface_map (src ,"spr_read_0",
                                         dest,"spr_read_"+toString(2*i  ));
 #endif
              PORT_MAP(_component ,src ,"out_SPR_READ_0_VAL"          , dest, "in_SPR_READ_"+toString(2*i  )+"_VAL"          );
              PORT_MAP(_component ,src , "in_SPR_READ_0_ACK"          , dest,"out_SPR_READ_"+toString(2*i  )+"_ACK"          );
+                                        dest,"spr_read_"+toString(i));
+#endif
+             COMPONENT_MAP(_component ,src ,"out_SPR_READ_0_VAL"          , dest, "in_SPR_READ_"+toString(i)+"_VAL"          );
+             COMPONENT_MAP(_component ,src , "in_SPR_READ_0_ACK"          , dest,"out_SPR_READ_"+toString(i)+"_ACK"          );
              if (_param->_have_port_ooo_engine_id)
              PORT_MAP(_component ,src ,"out_SPR_READ_0_OOO_ENGINE_ID", dest, "in_SPR_READ_"+toString(2*i  )+"_OOO_ENGINE_ID");
              PORT_MAP(_component ,src ,"out_SPR_READ_0_NUM_REG"      , dest, "in_SPR_READ_"+toString(2*i  )+"_NUM_REG"      );
              PORT_MAP(_component ,src , "in_SPR_READ_0_DATA"         , dest,"out_SPR_READ_"+toString(2*i  )+"_DATA"         );
              PORT_MAP(_component ,src , "in_SPR_READ_0_DATA_VAL"     , dest,"out_SPR_READ_"+toString(2*i  )+"_DATA_VAL"     );
+             COMPONENT_MAP(_component ,src ,"out_SPR_READ_0_OOO_ENGINE_ID", dest, "in_SPR_READ_"+toString(i)+"_OOO_ENGINE_ID");
+             COMPONENT_MAP(_component ,src ,"out_SPR_READ_0_NUM_REG"      , dest, "in_SPR_READ_"+toString(i)+"_NUM_REG"      );
+             COMPONENT_MAP(_component ,src , "in_SPR_READ_0_DATA"         , dest,"out_SPR_READ_"+toString(i)+"_DATA"         );
+             COMPONENT_MAP(_component ,src , "in_SPR_READ_0_DATA_VAL"     , dest,"out_SPR_READ_"+toString(i)+"_DATA_VAL"     );
+           }
 …
                 it++)
+             {
+               dest = _name+"_write_unit_"+toString(*it);
+               uint32_t num_port = (*it);
+               dest = _name+"_glue";
 #ifdef POSITION
                _component->interface_map (src ,"gpr_write_"+toString(it_gpr_write),
                                           dest,"gpr_write");
+                                          dest,"gpr_write_read_unit_"+toString(num_port));
 #endif
                PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_VAL"          ,
                                     dest,"out_GPR_WRITE_0_VAL"          );
+               COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_VAL"          ,
+                                         dest,"out_GPR_WRITE_READ_UNIT_"+toString(num_port)+"_VAL"          );
                if (_param->_have_port_ooo_engine_id)
+               PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_OOO_ENGINE_ID",
+                                    dest,"out_GPR_WRITE_0_OOO_ENGINE_ID");
+               PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_NUM_REG"      ,
+                                    dest,"out_GPR_WRITE_0_NUM_REG"      );
+               PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_DATA"         ,
+                                    dest,"out_GPR_WRITE_0_DATA"         );
+               // PORT MAP to the "write_unit" component
+#ifdef POSITION
+               _component->interface_map (dest,"gpr_write",
+                                          src ,"gpr_write_"+toString(it_gpr_write));
+#endif
+               PORT_MAP(_component ,dest,"out_GPR_WRITE_0_VAL"          ,
+                                    src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_VAL"          );
+               if (_param->_have_port_ooo_engine_id)
+               PORT_MAP(_component ,dest,"out_GPR_WRITE_0_OOO_ENGINE_ID",
+                                    src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_OOO_ENGINE_ID");
+               PORT_MAP(_component ,dest,"out_GPR_WRITE_0_NUM_REG"      ,
+                                    src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_NUM_REG"      );
+               PORT_MAP(_component ,dest,"out_GPR_WRITE_0_DATA"         ,
+                                    src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_DATA"         );
+               COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_OOO_ENGINE_ID",
+                                         dest,"out_GPR_WRITE_READ_UNIT_"+toString(num_port)+"_OOO_ENGINE_ID");
+               COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_NUM_REG"      ,
+                                         dest,"out_GPR_WRITE_READ_UNIT_"+toString(num_port)+"_NUM_REG"      );
+               COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(it_gpr_write)+"_DATA"         ,
+                                         dest,"out_GPR_WRITE_READ_UNIT_"+toString(num_port)+"_DATA"         );
                it_gpr_write ++;
 …
                 it++)
+             {
+               dest = _name+"_write_unit_"+toString(*it);
+               uint32_t num_port = (*it);
+               dest = _name+"_glue";
 #ifdef POSITION
                _component->interface_map (src ,"spr_write_"+toString(it_spr_write),
                                           dest,"spr_write");
+                                          dest,"spr_write_read_unit_"+toString(num_port));
 #endif
+               PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_VAL"          ,
+                                    dest,"out_SPR_WRITE_0_VAL"          );
+               COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_VAL"          ,
+                                         dest,"out_SPR_WRITE_READ_UNIT_"+toString(num_port)+"_VAL"          );
                if (_param->_have_port_ooo_engine_id)
+               PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_OOO_ENGINE_ID",
+                                    dest,"out_SPR_WRITE_0_OOO_ENGINE_ID");
+               PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_NUM_REG"      ,
+                                    dest,"out_SPR_WRITE_0_NUM_REG"      );
+               PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_DATA"         ,
+                                    dest,"out_SPR_WRITE_0_DATA"         );
+               // PORT MAP to the "write_unit" component
+#ifdef POSITION
+               _component->interface_map (dest,"spr_write",
+                                          src ,"spr_write_"+toString(it_spr_write));
+#endif
+               PORT_MAP(_component ,dest,"out_SPR_WRITE_0_VAL"          ,
+                                    src , "in_SPR_WRITE_"+toString(it_spr_write)+"_VAL"          );
+               if (_param->_have_port_ooo_engine_id)
+               PORT_MAP(_component ,dest,"out_SPR_WRITE_0_OOO_ENGINE_ID",
+                                    src , "in_SPR_WRITE_"+toString(it_spr_write)+"_OOO_ENGINE_ID");
+               PORT_MAP(_component ,dest,"out_SPR_WRITE_0_NUM_REG"      ,
+                                    src , "in_SPR_WRITE_"+toString(it_spr_write)+"_NUM_REG"      );
+               PORT_MAP(_component ,dest,"out_SPR_WRITE_0_DATA"         ,
+                                    src , "in_SPR_WRITE_"+toString(it_spr_write)+"_DATA"         );
+               COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_OOO_ENGINE_ID",
+                                         dest,"out_SPR_WRITE_READ_UNIT_"+toString(num_port)+"_OOO_ENGINE_ID");
+               COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_NUM_REG"      ,
+                                         dest,"out_SPR_WRITE_READ_UNIT_"+toString(num_port)+"_NUM_REG"      );
+               COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(it_spr_write)+"_DATA"         ,
+                                         dest,"out_SPR_WRITE_READ_UNIT_"+toString(num_port)+"_DATA"         );
                it_spr_write ++;
+             }
 …
                    if (_param->_have_port_ooo_engine_id)
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_OOO_ENGINE_ID",
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_OOO_ENGINE_ID");
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_VAL"      ,
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_VAL"      );
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_NUM_REG"  ,
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_NUM_REG"  );
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_DATA"     ,
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_DATA"     );
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_VAL"      ,
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_VAL"      );
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_NUM_REG"  ,
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_NUM_REG"  );
                    PORT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_DATA"     ,
                                         dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_DATA"     );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_OOO_ENGINE_ID",
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_OOO_ENGINE_ID");
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_VAL"      ,
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_VAL"      );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_NUM_REG"  ,
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_NUM_REG"  );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_DATA"     ,
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_DATA"     );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_VAL"      ,
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_VAL"      );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_NUM_REG"  ,
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_NUM_REG"  );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_DATA"     ,
+                                             dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_DATA"     );
 #ifdef POSITION
 …
 #endif
                    if (_param->_have_port_ooo_engine_id)
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_OOO_ENGINE_ID",
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_OOO_ENGINE_ID");
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_VAL"      ,
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_VAL"      );
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_NUM_REG"  ,
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_NUM_REG"  );
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_DATA"     ,
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_DATA"     );
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_VAL"      ,
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_VAL"      );
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_NUM_REG"  ,
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_NUM_REG"  );
                    PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_DATA"     ,
                                         src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_DATA"     );
+//                 if (_param->_have_port_ooo_engine_id)
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_OOO_ENGINE_ID",
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_OOO_ENGINE_ID");
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_VAL"      ,
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_VAL"      );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_NUM_REG"  ,
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_NUM_REG"  );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_GPR_DATA"     ,
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_GPR_DATA"     );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_VAL"      ,
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_VAL"      );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_NUM_REG"  ,
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_NUM_REG"  );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_WRITE_"+toString(j              )+"_SPR_DATA"     ,
+//                                      src , "in_BYPASS_WRITE_"+toString(it_bypass_write)+"_SPR_DATA"     );
                    it_bypass_write ++;
 …
                    if (_param->_have_port_ooo_engine_id)
                    PORT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_OOO_ENGINE_ID",
                                         dest,"out_BYPASS_MEMORY_"+toString(j               )+"_OOO_ENGINE_ID");
                    PORT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_VAL"          ,
                                         dest,"out_BYPASS_MEMORY_"+toString(j               )+"_VAL"          );
                    PORT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_NUM_REG"      ,
                                         dest,"out_BYPASS_MEMORY_"+toString(j               )+"_NUM_REG"      );
                    PORT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_DATA"         ,
                                         dest,"out_BYPASS_MEMORY_"+toString(j               )+"_DATA"         );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_OOO_ENGINE_ID",
+                                             dest,"out_BYPASS_MEMORY_"+toString(j               )+"_OOO_ENGINE_ID");
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_VAL"          ,
+                                             dest,"out_BYPASS_MEMORY_"+toString(j               )+"_VAL"          );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_NUM_REG"      ,
+                                             dest,"out_BYPASS_MEMORY_"+toString(j               )+"_NUM_REG"      );
+                   COMPONENT_MAP(_component ,src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_DATA"         ,
+                                             dest,"out_BYPASS_MEMORY_"+toString(j               )+"_DATA"         );
                    // port map to the "load_store_unit" component
 …
 #endif
                    if (_param->_have_port_ooo_engine_id)
                    PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_OOO_ENGINE_ID",
                                         src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_OOO_ENGINE_ID");
                    PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_VAL"          ,
                                         src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_VAL"          );
                    PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_NUM_REG"      ,
                                         src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_NUM_REG"      );
                    PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_DATA"         ,
                                         src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_DATA"         );
+//                 if (_param->_have_port_ooo_engine_id)
+//                 PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_OOO_ENGINE_ID",
+//                                      src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_OOO_ENGINE_ID");
+//                 PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_VAL"          ,
+//                                      src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_VAL"          );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_NUM_REG"      ,
+//                                      src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_NUM_REG"      );
+//                 PORT_MAP(_component ,dest,"out_BYPASS_MEMORY_"+toString(j               )+"_DATA"         ,
+//                                      src , "in_BYPASS_MEMORY_"+toString(it_bypass_memory)+"_DATA"         );
                    it_bypass_memory ++;
 …
              src = _name+"_functionnal_unit_"+toString(x);
              std::cout << "Instance : " << src << std::endl;
+             log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+             {
 …
 #ifdef POSITION
                _component->interface_map (src ,"execute_in",
                                           dest,"execute_unit_in_"+toString(i));
 #endif
                PORT_MAP(_component ,src , "in_EXECUTE_IN_VAL"                  ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_VAL"                  );
                PORT_MAP(_component ,src ,"out_EXECUTE_IN_ACK"                  ,
                                     dest, "in_EXECUTE_UNIT_IN_"+toString(i)+"_ACK"                  );
+                                          dest,"execute_unit_in_"+toString(i)+"_0");
+#endif
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_VAL"                  ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_VAL"                  );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_IN_ACK"                  ,
+                                         dest, "in_EXECUTE_UNIT_IN_"+toString(i)+"_0_ACK"                  );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src , "in_EXECUTE_IN_CONTEXT_ID"           ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"           );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_CONTEXT_ID"           ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_CONTEXT_ID"           );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src , "in_EXECUTE_IN_FRONT_END_ID"         ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_FRONT_END_ID"         );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_FRONT_END_ID"         ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_FRONT_END_ID"         );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src , "in_EXECUTE_IN_OOO_ENGINE_ID"        ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID"        );
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src , "in_EXECUTE_IN_PACKET_ID"            ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_PACKET_ID"            );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_OPERATION"            ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OPERATION"            );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_TYPE"                 ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_TYPE"                 );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE",
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_STORE_QUEUE_PTR_WRITE");
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_OOO_ENGINE_ID"        ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_OOO_ENGINE_ID"        );
+               if (_param->_have_port_rob_ptr  )
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_PACKET_ID"            ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_PACKET_ID"            );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_OPERATION"            ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_OPERATION"            );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_TYPE"                 ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_TYPE"                 );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE",
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_STORE_QUEUE_PTR_WRITE");
                if (_param->_have_port_load_queue_ptr)
                PORT_MAP(_component ,src , "in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE" ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_HAS_IMMEDIAT"         ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_HAS_IMMEDIAT"         );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_IMMEDIAT"             ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_IMMEDIAT"             );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_DATA_RA"              ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RA"              );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_DATA_RB"              ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RB"              );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_DATA_RC"              ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RC"              );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_WRITE_RD"             ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RD"             );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_NUM_REG_RD"           ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"           );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_WRITE_RE"             ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RE"             );
                PORT_MAP(_component ,src , "in_EXECUTE_IN_NUM_REG_RE"           ,
                                     dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"           );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE" ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_LOAD_QUEUE_PTR_WRITE" );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_HAS_IMMEDIAT"         ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_HAS_IMMEDIAT"         );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_IMMEDIAT"             ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_IMMEDIAT"             );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_DATA_RA"              ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_DATA_RA"              );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_DATA_RB"              ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_DATA_RB"              );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_DATA_RC"              ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_DATA_RC"              );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_WRITE_RD"             ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_WRITE_RD"             );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_NUM_REG_RD"           ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_NUM_REG_RD"           );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_WRITE_RE"             ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_WRITE_RE"             );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_IN_NUM_REG_RE"           ,
+                                         dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_0_NUM_REG_RE"           );
+             }
 …
 #ifdef POSITION
                _component->interface_map (src ,"execute_out",
                                           dest,"execute_unit_out_"+toString(i));
 #endif
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_VAL"          ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_VAL"          );
                PORT_MAP(_component ,src , "in_EXECUTE_OUT_ACK"          ,
                                     dest,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_ACK"          );
+                                          dest,"execute_unit_out_"+toString(i)+"_0");
+#endif
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_VAL"          ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_VAL"          );
+               COMPONENT_MAP(_component ,src , "in_EXECUTE_OUT_ACK"          ,
+                                         dest,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_0_ACK"          );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_CONTEXT_ID"   ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_CONTEXT_ID"   );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_CONTEXT_ID"   ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_CONTEXT_ID"   );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_FRONT_END_ID" ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_FRONT_END_ID" );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_FRONT_END_ID" ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_FRONT_END_ID" );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_OOO_ENGINE_ID",
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID");
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_PACKET_ID"    ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_PACKET_ID"    );
 //             PORT_MAP(_component ,src ,"out_EXECUTE_OUT_OPERATION"    ,
 //                                  dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OPERATION"    );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_TYPE"         ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_TYPE"         );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_WRITE_RD"     ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RD"     );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_NUM_REG_RD"   ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RD"   );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_DATA_RD"      ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RD"      );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_WRITE_RE"     ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RE"     );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_NUM_REG_RE"   ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RE"   );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_DATA_RE"      ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RE"      );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_EXCEPTION"    ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_EXCEPTION"    );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_NO_SEQUENCE"  ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NO_SEQUENCE"  );
                PORT_MAP(_component ,src ,"out_EXECUTE_OUT_ADDRESS"      ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_ADDRESS"      );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_OOO_ENGINE_ID",
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_OOO_ENGINE_ID");
+               if (_param->_have_port_rob_ptr  )
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_PACKET_ID"    ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_PACKET_ID"    );
+//             COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_OPERATION"    ,
+//                                       dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_OPERATION"    );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_TYPE"         ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_TYPE"         );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_WRITE_RD"     ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_WRITE_RD"     );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_NUM_REG_RD"   ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_NUM_REG_RD"   );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_DATA_RD"      ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_DATA_RD"      );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_WRITE_RE"     ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_WRITE_RE"     );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_NUM_REG_RE"   ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_NUM_REG_RE"   );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_DATA_RE"      ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_DATA_RE"      );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_EXCEPTION"    ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_EXCEPTION"    );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_NO_SEQUENCE"  ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_NO_SEQUENCE"  );
+               COMPONENT_MAP(_component ,src ,"out_EXECUTE_OUT_ADDRESS"      ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_0_ADDRESS"      );
+             }
+           }
 …
              src = _name+"_load_store_unit_"+toString(x);
              std::cout << "Instance : " << src << std::endl;
+             log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
              // ~~~~~[ Interface "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
              // ~~~~~[ Interface "memory_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+             {
+               dest = _name+"_read_unit_to_execution_unit";
+#ifdef POSITION
+               _component->interface_map (src ,"memory_in",
+                                          dest,"execute_unit_in_"+toString(i));
+#endif
+               PORT_MAP(_component ,src , "in_MEMORY_IN_VAL"                  ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_VAL"                  );
+               PORT_MAP(_component ,src ,"out_MEMORY_IN_ACK"                  ,
+                                    dest, "in_EXECUTE_UNIT_IN_"+toString(i)+"_ACK"                  );
+               if (_param->_have_port_context_id)
+               PORT_MAP(_component ,src , "in_MEMORY_IN_CONTEXT_ID"           ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"           );
+               if (_param->_have_port_front_end_id)
+               PORT_MAP(_component ,src , "in_MEMORY_IN_FRONT_END_ID"         ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_FRONT_END_ID"         );
+               if (_param->_have_port_ooo_engine_id)
+               PORT_MAP(_component ,src , "in_MEMORY_IN_OOO_ENGINE_ID"        ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID"        );
+               if (_param->_have_port_packet_id)
+               PORT_MAP(_component ,src , "in_MEMORY_IN_PACKET_ID"            ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_PACKET_ID"            );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_OPERATION"            ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OPERATION"            );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_TYPE"                 ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_TYPE"                 );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_STORE_QUEUE_PTR_WRITE",
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_STORE_QUEUE_PTR_WRITE");
+               if (_param->_have_port_load_queue_ptr)
+               PORT_MAP(_component ,src , "in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE" ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_HAS_IMMEDIAT"         ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_HAS_IMMEDIAT"         );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_IMMEDIAT"             ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_IMMEDIAT"             );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_DATA_RA"              ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RA"              );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_DATA_RB"              ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RB"              );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_DATA_RC"              ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RC"              );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_WRITE_RD"             ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RD"             );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_NUM_REG_RD"           ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"           );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_WRITE_RE"             ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RE"             );
+               PORT_MAP(_component ,src , "in_MEMORY_IN_NUM_REG_RE"           ,
+                                    dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"           );
+             }
+             for (uint32_t j=0; j<_param->_nb_inst_memory [x]; j++)
+               {
+                 dest = _name+"_read_unit_to_execution_unit";
+#ifdef POSITION
+                 _component->interface_map (src ,"memory_in_"+toString(j),
+                                            dest,"execute_unit_in_"+toString(i)+"_"+toString(j));
+#endif
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_VAL"                  ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_VAL"                  );
+                 COMPONENT_MAP(_component ,src ,"out_MEMORY_IN_"+toString(j)+"_ACK"                  ,
+                                           dest, "in_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_ACK"                  );
+                 if (_param->_have_port_context_id)
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_CONTEXT_ID"           ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_CONTEXT_ID"           );
+                 if (_param->_have_port_front_end_id)
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_FRONT_END_ID"         ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_FRONT_END_ID"         );
+                 if (_param->_have_port_ooo_engine_id)
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_OOO_ENGINE_ID"        ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_OOO_ENGINE_ID"        );
+                 if (_param->_have_port_rob_ptr  )
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_PACKET_ID"            ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_PACKET_ID"            );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_OPERATION"            ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_OPERATION"            );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_TYPE"                 ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_TYPE"                 );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_STORE_QUEUE_PTR_WRITE",
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_STORE_QUEUE_PTR_WRITE");
+                 if (_param->_have_port_load_queue_ptr)
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_LOAD_QUEUE_PTR_WRITE" ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_LOAD_QUEUE_PTR_WRITE" );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_HAS_IMMEDIAT"         ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_HAS_IMMEDIAT"         );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_IMMEDIAT"             ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_IMMEDIAT"             );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_DATA_RA"              ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_DATA_RA"              );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_DATA_RB"              ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_DATA_RB"              );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_DATA_RC"              ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_DATA_RC"              );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_WRITE_RD"             ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_WRITE_RD"             );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_NUM_REG_RD"           ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_NUM_REG_RD"           );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_WRITE_RE"             ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_WRITE_RE"             );
+                 COMPONENT_MAP(_component ,src , "in_MEMORY_IN_"+toString(j)+"_NUM_REG_RE"           ,
+                                           dest,"out_EXECUTE_UNIT_IN_"+toString(i)+"_"+toString(j)+"_NUM_REG_RE"           );
+               }
              // ~~~~~[ Interface "memory_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+             {
+             for (uint32_t j=0; j<_param->_nb_inst_memory [x]; j++)
+               {
                dest = _name+"_execution_unit_to_write_unit";
 #ifdef POSITION
                _component->interface_map (src ,"memory_out",
                                           dest,"execute_unit_out_"+toString(i));
 #endif
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_VAL"          ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_VAL"          );
                PORT_MAP(_component ,src , "in_MEMORY_OUT_ACK"          ,
                                     dest,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_ACK"          );
+               _component->interface_map (src ,"memory_out_"+toString(j)
+                                          dest,"execute_unit_out_"+toString(i)+"_"+toString(j));
+#endif
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_VAL"          ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_VAL"          );
+               COMPONENT_MAP(_component ,src , "in_MEMORY_OUT_"+toString(j)+"_ACK"          ,
+                                         dest,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_ACK"          );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_CONTEXT_ID"   ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_CONTEXT_ID"   );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_CONTEXT_ID"   ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_CONTEXT_ID"   );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_FRONT_END_ID" ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_FRONT_END_ID" );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_FRONT_END_ID" ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_FRONT_END_ID" );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_OOO_ENGINE_ID",
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID");
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_PACKET_ID"    ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_PACKET_ID"    );
 //             PORT_MAP(_component ,src ,"out_MEMORY_OUT_OPERATION"    ,
 //                                  dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OPERATION"    );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_TYPE"         ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_TYPE"         );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_WRITE_RD"     ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RD"     );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_NUM_REG_RD"   ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RD"   );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_DATA_RD"      ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RD"      );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_WRITE_RE"     ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RE"     );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_NUM_REG_RE"   ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RE"   );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_DATA_RE"      ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RE"      );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_EXCEPTION"    ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_EXCEPTION"    );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_NO_SEQUENCE"  ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NO_SEQUENCE"  );
                PORT_MAP(_component ,src ,"out_MEMORY_OUT_ADDRESS"      ,
                                     dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_ADDRESS"      );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_OOO_ENGINE_ID",
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_OOO_ENGINE_ID");
+               if (_param->_have_port_rob_ptr  )
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_PACKET_ID"    ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_PACKET_ID"    );
+//             COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_OPERATION"    ,
+//                                       dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_OPERATION"    );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_TYPE"         ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_TYPE"         );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_WRITE_RD"     ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_WRITE_RD"     );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_NUM_REG_RD"   ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_NUM_REG_RD"   );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_DATA_RD"      ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_DATA_RD"      );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_WRITE_RE"     ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_WRITE_RE"     );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_NUM_REG_RE"   ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_NUM_REG_RE"   );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_DATA_RE"      ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_DATA_RE"      );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_EXCEPTION"    ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_EXCEPTION"    );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_NO_SEQUENCE"  ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_NO_SEQUENCE"  );
+               COMPONENT_MAP(_component ,src ,"out_MEMORY_OUT_"+toString(j)+"_ADDRESS"      ,
+                                         dest, "in_EXECUTE_UNIT_OUT_"+toString(i)+"_"+toString(j)+"_ADDRESS"      );
+             }
              // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+             for (uint32_t j=0; j<_param->_nb_cache_port [x]; j++)
+             {
                dest = _name;
 #ifdef POSITION
                _component->interface_map (src ,"dcache_req",
                                           dest,"dcache_req_"+toString(i));
 #endif
                PORT_MAP(_component ,src ,"out_DCACHE_REQ_VAL"       ,dest,"out_DCACHE_REQ_"+toString(i)+"_VAL"       );
                PORT_MAP(_component ,src , "in_DCACHE_REQ_ACK"       ,dest, "in_DCACHE_REQ_"+toString(i)+"_ACK"       );
+               _component->interface_map (src ,"dcache_req_"+toString(j),
+                                          dest,"dcache_req_"+toString(x)+"_"+toString(j));
+#endif
+               PORT_MAP(_component ,src ,"out_DCACHE_REQ_"+toString(j)+"_VAL"       ,dest,"out_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_VAL"       );
+               PORT_MAP(_component ,src , "in_DCACHE_REQ_"+toString(j)+"_ACK"       ,dest, "in_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_ACK"       );
                if (_param->_have_port_dcache_context_id)
                PORT_MAP(_component ,src ,"out_DCACHE_REQ_CONTEXT_ID",dest,"out_DCACHE_REQ_"+toString(i)+"_CONTEXT_ID");
                PORT_MAP(_component ,src ,"out_DCACHE_REQ_PACKET_ID" ,dest,"out_DCACHE_REQ_"+toString(i)+"_PACKET_ID" );
                PORT_MAP(_component ,src ,"out_DCACHE_REQ_ADDRESS"   ,dest,"out_DCACHE_REQ_"+toString(i)+"_ADDRESS"   );
                PORT_MAP(_component ,src ,"out_DCACHE_REQ_TYPE"      ,dest,"out_DCACHE_REQ_"+toString(i)+"_TYPE"      );
                PORT_MAP(_component ,src ,"out_DCACHE_REQ_WDATA"     ,dest,"out_DCACHE_REQ_"+toString(i)+"_WDATA"     );
+               PORT_MAP(_component ,src ,"out_DCACHE_REQ_"+toString(j)+"_CONTEXT_ID",dest,"out_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_CONTEXT_ID");
+               PORT_MAP(_component ,src ,"out_DCACHE_REQ_"+toString(j)+"_PACKET_ID" ,dest,"out_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_PACKET_ID" );
+               PORT_MAP(_component ,src ,"out_DCACHE_REQ_"+toString(j)+"_ADDRESS"   ,dest,"out_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_ADDRESS"   );
+               PORT_MAP(_component ,src ,"out_DCACHE_REQ_"+toString(j)+"_TYPE"      ,dest,"out_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_TYPE"      );
+               PORT_MAP(_component ,src ,"out_DCACHE_REQ_"+toString(j)+"_WDATA"     ,dest,"out_DCACHE_REQ_"+toString(x)+"_"+toString(j)+"_WDATA"     );
+             }
              // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+             for (uint32_t j=0; j<_param->_nb_cache_port [x]; j++)
+             {
                dest = _name;
 #ifdef POSITION
                _component->interface_map (src ,"dcache_rsp",
                                           dest,"dcache_rsp_"+toString(i));
 #endif
                PORT_MAP(_component ,src , "in_DCACHE_RSP_VAL"       ,dest, "in_DCACHE_RSP_"+toString(i)+"_VAL"       );
                PORT_MAP(_component ,src ,"out_DCACHE_RSP_ACK"       ,dest,"out_DCACHE_RSP_"+toString(i)+"_ACK"       );
+               _component->interface_map (src ,"dcache_rsp_"+toString(j),
+                                          dest,"dcache_rsp_"+toString(x)+"_"+toString(j));
+#endif
+               PORT_MAP(_component ,src , "in_DCACHE_RSP_"+toString(j)+"_VAL"       ,dest, "in_DCACHE_RSP_"+toString(x)+"_"+toString(j)+"_VAL"       );
+               PORT_MAP(_component ,src ,"out_DCACHE_RSP_"+toString(j)+"_ACK"       ,dest,"out_DCACHE_RSP_"+toString(x)+"_"+toString(j)+"_ACK"       );
                if (_param->_have_port_dcache_context_id)
                PORT_MAP(_component ,src , "in_DCACHE_RSP_CONTEXT_ID",dest, "in_DCACHE_RSP_"+toString(i)+"_CONTEXT_ID");
                PORT_MAP(_component ,src , "in_DCACHE_RSP_PACKET_ID" ,dest, "in_DCACHE_RSP_"+toString(i)+"_PACKET_ID" );
                PORT_MAP(_component ,src , "in_DCACHE_RSP_RDATA"     ,dest, "in_DCACHE_RSP_"+toString(i)+"_RDATA"     );
                PORT_MAP(_component ,src , "in_DCACHE_RSP_ERROR"     ,dest, "in_DCACHE_RSP_"+toString(i)+"_ERROR"     );
+               PORT_MAP(_component ,src , "in_DCACHE_RSP_"+toString(j)+"_CONTEXT_ID",dest, "in_DCACHE_RSP_"+toString(x)+"_"+toString(j)+"_CONTEXT_ID");
+               PORT_MAP(_component ,src , "in_DCACHE_RSP_"+toString(j)+"_PACKET_ID" ,dest, "in_DCACHE_RSP_"+toString(x)+"_"+toString(j)+"_PACKET_ID" );
+               PORT_MAP(_component ,src , "in_DCACHE_RSP_"+toString(j)+"_RDATA"     ,dest, "in_DCACHE_RSP_"+toString(x)+"_"+toString(j)+"_RDATA"     );
+               PORT_MAP(_component ,src , "in_DCACHE_RSP_"+toString(j)+"_ERROR"     ,dest, "in_DCACHE_RSP_"+toString(x)+"_"+toString(j)+"_ERROR"     );
+             }
 …
+       {
          src = _name+"_write_unit_"+toString(i);
          std::cout << "Instance : " << src << std::endl;
+         log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+         {
 …
 #endif
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_VAL"          ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_VAL"          );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_ACK"          ,
                                 dest, "in_WRITE_UNIT_IN_"+toString(i)+"_ACK"          );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_VAL"          ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_VAL"          );
+           COMPONENT_MAP(_component ,src ,"out_WRITE_UNIT_IN_ACK"          ,
+                                     dest, "in_WRITE_UNIT_IN_"+toString(i)+"_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_CONTEXT_ID"   ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"   );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_CONTEXT_ID"   ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"   );
            if (_param->_have_port_front_end_id)
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_FRONT_END_ID" ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_FRONT_END_ID" );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_FRONT_END_ID" ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_FRONT_END_ID" );
            if (_param->_have_port_ooo_engine_id)
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_OOO_ENGINE_ID",
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID");
            if (_param->_have_port_packet_id)
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_PACKET_ID"    ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_PACKET_ID"    );
 //         PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_OPERATION"    ,
 //                              dest,"out_WRITE_UNIT_IN_"+toString(i)+"_OPERATION"    );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_TYPE"         ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_TYPE"         );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_WRITE_RD"     ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RD"     );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_NUM_REG_RD"   ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"   );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_DATA_RD"      ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RD"      );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_WRITE_RE"     ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RE"     );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_NUM_REG_RE"   ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"   );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_DATA_RE"      ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RE"      );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_EXCEPTION"    ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_EXCEPTION"    );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_NO_SEQUENCE"  ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_NO_SEQUENCE"  );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_ADDRESS"      ,
                                 dest,"out_WRITE_UNIT_IN_"+toString(i)+"_ADDRESS"      );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_OOO_ENGINE_ID",
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID");
+           if (_param->_have_port_rob_ptr  )
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_PACKET_ID"    ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_PACKET_ID"    );
+//         COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_OPERATION"    ,
+//                                   dest,"out_WRITE_UNIT_IN_"+toString(i)+"_OPERATION"    );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_TYPE"         ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_TYPE"         );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_WRITE_RD"     ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RD"     );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_NUM_REG_RD"   ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"   );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_DATA_RD"      ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RD"      );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_WRITE_RE"     ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RE"     );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_NUM_REG_RE"   ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"   );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_DATA_RE"      ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RE"      );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_EXCEPTION"    ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_EXCEPTION"    );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_NO_SEQUENCE"  ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_NO_SEQUENCE"  );
+           COMPONENT_MAP(_component ,src , "in_WRITE_UNIT_IN_ADDRESS"      ,
+                                     dest,"out_WRITE_UNIT_IN_"+toString(i)+"_ADDRESS"      );
+         }
 …
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_OUT_OOO_ENGINE_ID",
                                 dest,"out_EXECUTE_LOOP_OUT_"+toString(i)+"_OOO_ENGINE_ID");
            if (_param->_have_port_packet_id)
+           if (_param->_have_port_rob_ptr  )
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_OUT_PACKET_ID"    ,
                                 dest,"out_EXECUTE_LOOP_OUT_"+toString(i)+"_PACKET_ID"    );
 …
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_OUT_ADDRESS"      ,
                                 dest,"out_EXECUTE_LOOP_OUT_"+toString(i)+"_ADDRESS"      );
+           PORT_MAP(_component ,src ,"out_WRITE_UNIT_OUT_DATA"         ,
+                                dest,"out_EXECUTE_LOOP_OUT_"+toString(i)+"_DATA"         );
+         }
          // -----[ Interface "gpr_write" ]-------------------------------------
+         {
+           // Port map with "read_unit" is ok!
+           dest = _name+"_register_unit";
+           dest = _name+"_glue";
 #ifdef POSITION
            _component->interface_map (src ,"gpr_write",
                                       dest,"gpr_write_"+toString(i));
 #endif
            PORT_MAP(_component ,src ,"out_GPR_WRITE_0_VAL"          ,
                                 dest, "in_GPR_WRITE_"+toString(i)+"_VAL"          );
            PORT_MAP(_component ,src , "in_GPR_WRITE_0_ACK"          ,
                                 dest,"out_GPR_WRITE_"+toString(i)+"_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src ,"out_GPR_WRITE_0_OOO_ENGINE_ID",
                                 dest, "in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
            PORT_MAP(_component ,src ,"out_GPR_WRITE_0_NUM_REG"      ,
                                 dest, "in_GPR_WRITE_"+toString(i)+"_NUM_REG"      );
            PORT_MAP(_component ,src ,"out_GPR_WRITE_0_DATA"         ,
                                 dest, "in_GPR_WRITE_"+toString(i)+"_DATA"         );
+                                      dest,"gpr_write_write_unit_"+toString(i));
+#endif
+           COMPONENT_MAP(_component ,src ,"out_GPR_WRITE_0_VAL"          ,
+                                     dest, "in_GPR_WRITE_WRITE_UNIT_"+toString(i)+"_VAL"          );
+           COMPONENT_MAP(_component ,src , "in_GPR_WRITE_0_ACK"          ,
+                                     dest,"out_GPR_WRITE_WRITE_UNIT_"+toString(i)+"_ACK"          );
+           if (_param->_have_port_ooo_engine_id)
+           COMPONENT_MAP(_component ,src ,"out_GPR_WRITE_0_OOO_ENGINE_ID",
+                                     dest, "in_GPR_WRITE_WRITE_UNIT_"+toString(i)+"_OOO_ENGINE_ID");
+           COMPONENT_MAP(_component ,src ,"out_GPR_WRITE_0_NUM_REG"      ,
+                                     dest, "in_GPR_WRITE_WRITE_UNIT_"+toString(i)+"_NUM_REG"      );
+           COMPONENT_MAP(_component ,src ,"out_GPR_WRITE_0_DATA"         ,
+                                     dest, "in_GPR_WRITE_WRITE_UNIT_"+toString(i)+"_DATA"         );
+         }
 …
            // Port map with "read_unit" is ok!
            dest = _name+"_register_unit";
+           dest = _name+"_glue";
 #ifdef POSITION
            _component->interface_map (src ,"spr_write",
                                       dest,"spr_write_"+toString(i));
 #endif
            PORT_MAP(_component ,src ,"out_SPR_WRITE_0_VAL"          ,
                                 dest, "in_SPR_WRITE_"+toString(i)+"_VAL"          );
            PORT_MAP(_component ,src , "in_SPR_WRITE_0_ACK"          ,
                                 dest,"out_SPR_WRITE_"+toString(i)+"_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src ,"out_SPR_WRITE_0_OOO_ENGINE_ID",
                                 dest, "in_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID");
            PORT_MAP(_component ,src ,"out_SPR_WRITE_0_NUM_REG"      ,
                                 dest, "in_SPR_WRITE_"+toString(i)+"_NUM_REG"      );
            PORT_MAP(_component ,src ,"out_SPR_WRITE_0_DATA"         ,
                                 dest, "in_SPR_WRITE_"+toString(i)+"_DATA"         );
+                                      dest,"spr_write_write_unit_"+toString(i));
+#endif
+           COMPONENT_MAP(_component ,src ,"out_SPR_WRITE_0_VAL"          ,
+                                     dest, "in_SPR_WRITE_WRITE_UNIT_"+toString(i)+"_VAL"          );
+           COMPONENT_MAP(_component ,src , "in_SPR_WRITE_0_ACK"          ,
+                                     dest,"out_SPR_WRITE_WRITE_UNIT_"+toString(i)+"_ACK"          );
+           if (_param->_have_port_ooo_engine_id)
+           COMPONENT_MAP(_component ,src ,"out_SPR_WRITE_0_OOO_ENGINE_ID",
+                                     dest, "in_SPR_WRITE_WRITE_UNIT_"+toString(i)+"_OOO_ENGINE_ID");
+           COMPONENT_MAP(_component ,src ,"out_SPR_WRITE_0_NUM_REG"      ,
+                                     dest, "in_SPR_WRITE_WRITE_UNIT_"+toString(i)+"_NUM_REG"      );
+           COMPONENT_MAP(_component ,src ,"out_SPR_WRITE_0_DATA"         ,
+                                     dest, "in_SPR_WRITE_WRITE_UNIT_"+toString(i)+"_DATA"         );
+         }
 …
+     {
        src = _name+"_register_unit";
        std::cout << "Instance : " << src << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+       {
 …
 #endif
          PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i  )+"_VAL"          ,dest,"out_GPR_READ_0_VAL"          );
          PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i  )+"_ACK"          ,dest, "in_GPR_READ_0_ACK"          );
          if (_param->_have_port_context_id)
          PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i  )+"_OOO_ENGINE_ID",dest,"out_GPR_READ_0_OOO_ENGINE_ID");
          PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i  )+"_NUM_REG"      ,dest,"out_GPR_READ_0_NUM_REG"      );
          PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i  )+"_DATA"         ,dest, "in_GPR_READ_0_DATA"         );
          PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i  )+"_DATA_VAL"     ,dest, "in_GPR_READ_0_DATA_VAL"     );
          PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i+1)+"_VAL"          ,dest,"out_GPR_READ_1_VAL"          );
          PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i+1)+"_ACK"          ,dest, "in_GPR_READ_1_ACK"          );
          if (_param->_have_port_context_id)
          PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i+1)+"_OOO_ENGINE_ID",dest,"out_GPR_READ_1_OOO_ENGINE_ID");
          PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i+1)+"_NUM_REG"      ,dest,"out_GPR_READ_1_NUM_REG"      );
          PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i+1)+"_DATA"         ,dest, "in_GPR_READ_1_DATA"         );
          PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i+1)+"_DATA_VAL"     ,dest, "in_GPR_READ_1_DATA_VAL"     );
+//       PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i  )+"_VAL"          ,dest,"out_GPR_READ_0_VAL"          );
+//       PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i  )+"_ACK"          ,dest, "in_GPR_READ_0_ACK"          );
+//       if (_param->_have_port_context_id)
+//       PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i  )+"_OOO_ENGINE_ID",dest,"out_GPR_READ_0_OOO_ENGINE_ID");
+//       PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i  )+"_NUM_REG"      ,dest,"out_GPR_READ_0_NUM_REG"      );
+//       PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i  )+"_DATA"         ,dest, "in_GPR_READ_0_DATA"         );
+//       PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i  )+"_DATA_VAL"     ,dest, "in_GPR_READ_0_DATA_VAL"     );
+//       PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i+1)+"_VAL"          ,dest,"out_GPR_READ_1_VAL"          );
+//       PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i+1)+"_ACK"          ,dest, "in_GPR_READ_1_ACK"          );
+//       if (_param->_have_port_context_id)
+//       PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i+1)+"_OOO_ENGINE_ID",dest,"out_GPR_READ_1_OOO_ENGINE_ID");
+//       PORT_MAP(_component ,src , "in_GPR_READ_"+toString(2*i+1)+"_NUM_REG"      ,dest,"out_GPR_READ_1_NUM_REG"      );
+//       PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i+1)+"_DATA"         ,dest, "in_GPR_READ_1_DATA"         );
+//       PORT_MAP(_component ,src ,"out_GPR_READ_"+toString(2*i+1)+"_DATA_VAL"     ,dest, "in_GPR_READ_1_DATA_VAL"     );
+         }
 …
        for (uint32_t i=0; i<_param->_nb_write_unit; i++)
+         {
            dest = _name+"_write_unit_"+toString(i);
 #ifdef POSITION
            _component->interface_map (src ,"gpr_write_"+toString(i)
                                       dest,"gpr_write_0");
 #endif
            PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_VAL"          ,dest,"out_GPR_WRITE_0_VAL"          );
            PORT_MAP(_component ,src ,"out_GPR_WRITE_"+toString(i)+"_ACK"          ,dest, "in_GPR_WRITE_0_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",dest,"out_GPR_WRITE_0_OOO_ENGINE_ID");
            PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_NUM_REG"      ,dest,"out_GPR_WRITE_0_NUM_REG"      );
            PORT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_DATA"         ,dest,"out_GPR_WRITE_0_DATA"         );
+           dest = _name+"_glue";
+#ifdef POSITION
+           _component->interface_map (src ,"gpr_write_"+toString(i),
+                                      dest,"gpr_write_register_file_"+toString(i));
+#endif
+           COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_VAL"          ,dest,"out_GPR_WRITE_REGISTER_FILE_"+toString(i)+"_VAL"          );
+           COMPONENT_MAP(_component ,src ,"out_GPR_WRITE_"+toString(i)+"_ACK"          ,dest, "in_GPR_WRITE_REGISTER_FILE_"+toString(i)+"_ACK"          );
+           if (_param->_have_port_ooo_engine_id)
+           COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",dest,"out_GPR_WRITE_REGISTER_FILE_"+toString(i)+"_OOO_ENGINE_ID");
+           COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_NUM_REG"      ,dest,"out_GPR_WRITE_REGISTER_FILE_"+toString(i)+"_NUM_REG"      );
+           COMPONENT_MAP(_component ,src , "in_GPR_WRITE_"+toString(i)+"_DATA"         ,dest,"out_GPR_WRITE_REGISTER_FILE_"+toString(i)+"_DATA"         );
+         }
 …
 #endif
            PORT_MAP(_component ,src , "in_SPR_READ_"+toString(i)+"_VAL"          ,dest,"out_SPR_READ_0_VAL"          );
            PORT_MAP(_component ,src ,"out_SPR_READ_"+toString(i)+"_ACK"          ,dest, "in_SPR_READ_0_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src , "in_SPR_READ_"+toString(i)+"_OOO_ENGINE_ID",dest,"out_SPR_READ_0_OOO_ENGINE_ID");
            PORT_MAP(_component ,src , "in_SPR_READ_"+toString(i)+"_NUM_REG"      ,dest,"out_SPR_READ_0_NUM_REG"      );
            PORT_MAP(_component ,src ,"out_SPR_READ_"+toString(i)+"_DATA"         ,dest, "in_SPR_READ_0_DATA"         );
            PORT_MAP(_component ,src ,"out_SPR_READ_"+toString(i)+"_DATA_VAL"     ,dest, "in_SPR_READ_0_DATA_VAL"     );
+//         PORT_MAP(_component ,src , "in_SPR_READ_"+toString(i)+"_VAL"          ,dest,"out_SPR_READ_0_VAL"          );
+//         PORT_MAP(_component ,src ,"out_SPR_READ_"+toString(i)+"_ACK"          ,dest, "in_SPR_READ_0_ACK"          );
+//         if (_param->_have_port_context_id)
+//         PORT_MAP(_component ,src , "in_SPR_READ_"+toString(i)+"_OOO_ENGINE_ID",dest,"out_SPR_READ_0_OOO_ENGINE_ID");
+//         PORT_MAP(_component ,src , "in_SPR_READ_"+toString(i)+"_NUM_REG"      ,dest,"out_SPR_READ_0_NUM_REG"      );
+//         PORT_MAP(_component ,src ,"out_SPR_READ_"+toString(i)+"_DATA"         ,dest, "in_SPR_READ_0_DATA"         );
+//         PORT_MAP(_component ,src ,"out_SPR_READ_"+toString(i)+"_DATA_VAL"     ,dest, "in_SPR_READ_0_DATA_VAL"     );
+         }
 …
        for (uint32_t i=0; i<_param->_nb_write_unit; i++)
+         {
            dest = _name+"_write_unit_"+toString(i);
 #ifdef POSITION
            _component->interface_map (src ,"spr_write_"+toString(i)
                                       dest,"spr_write_0");
 #endif
            PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_VAL"          ,dest,"out_SPR_WRITE_0_VAL"          );
            PORT_MAP(_component ,src ,"out_SPR_WRITE_"+toString(i)+"_ACK"          ,dest, "in_SPR_WRITE_0_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",dest,"out_SPR_WRITE_0_OOO_ENGINE_ID");
            PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_NUM_REG"      ,dest,"out_SPR_WRITE_0_NUM_REG"      );
            PORT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_DATA"         ,dest,"out_SPR_WRITE_0_DATA"         );
+           dest = _name+"_glue";
+#ifdef POSITION
+           _component->interface_map (src ,"spr_write_"+toString(i),
+                                      dest,"spr_write_register_file_"+toString(i));
+#endif
+           COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_VAL"          ,dest,"out_SPR_WRITE_REGISTER_FILE_"+toString(i)+"_VAL"          );
+           COMPONENT_MAP(_component ,src ,"out_SPR_WRITE_"+toString(i)+"_ACK"          ,dest, "in_SPR_WRITE_REGISTER_FILE_"+toString(i)+"_ACK"          );
+           if (_param->_have_port_ooo_engine_id)
+           COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID",dest,"out_SPR_WRITE_REGISTER_FILE_"+toString(i)+"_OOO_ENGINE_ID");
+           COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_NUM_REG"      ,dest,"out_SPR_WRITE_REGISTER_FILE_"+toString(i)+"_NUM_REG"      );
+           COMPONENT_MAP(_component ,src , "in_SPR_WRITE_"+toString(i)+"_DATA"         ,dest,"out_SPR_WRITE_REGISTER_FILE_"+toString(i)+"_DATA"         );
+         }
 …
+         }
        // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+         {
            uint32_t x=_param->_nb_inst_retire_rob [i];
+//        // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+//       {
+//         uint32_t x=_param->_nb_inst_retire_rob [i];
            for (uint32_t j=0; j<x; j++)
+             {
                dest = _name;
 #ifdef POSITION
                _component->interface_map (src ,"retire_rob_"+toString(i)+"_"+toString(j),
                                           dest,"retire_rob_"+toString(i)+"_"+toString(j));
 #endif
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL"           ,
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL"           );
                PORT_MAP(_component ,src ,"out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK"           ,
                                     dest,"out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK"           );
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE"    ,
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE"    );
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG",
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG");
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE"    ,
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE"    );
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG",
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG");
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE"    ,
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE"    );
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG",
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG");
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE"    ,
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE"    );
                PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG",
                                     dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG");
+             }
+         }
+//         for (uint32_t j=0; j<x; j++)
+//           {
+//             dest = _name;
+// #ifdef POSITION
+//             _component->interface_map (src ,"retire_rob_"+toString(i)+"_"+toString(j),
+//                                        dest,"retire_rob_"+toString(i)+"_"+toString(j));
+// #endif
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL"           ,
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_VAL"           );
+//             PORT_MAP(_component ,src ,"out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK"           ,
+//                                  dest,"out_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_ACK"           );
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE"    ,
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_USE"    );
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG",
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_OLD_NUM_REG");
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE"    ,
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_USE"    );
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG",
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RD_NEW_NUM_REG");
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE"    ,
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_USE"    );
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG",
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_OLD_NUM_REG");
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE"    ,
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_USE"    );
+//             PORT_MAP(_component ,src , "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG",
+//                                  dest, "in_RETIRE_ROB_"+toString(i)+"_"+toString(j)+"_RE_NEW_NUM_REG");
+//           }
+//       }
+     }
 …
+     {
        src = _name+"_read_unit_to_execution_unit";
        std::cout << "Instance : " << src << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+       {
 …
 #endif
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_VAL"                  ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_VAL"                  );
              PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_ACK"                  ,
                                   dest, "in_READ_UNIT_OUT_"+toString(j               )+"_ACK"                  );
              if (_param->_have_port_context_id)
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_CONTEXT_ID"           ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_CONTEXT_ID"           );
              if (_param->_have_port_front_end_id)
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_FRONT_END_ID"         ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_FRONT_END_ID"         );
              if (_param->_have_port_ooo_engine_id)
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_OOO_ENGINE_ID"        ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_OOO_ENGINE_ID"        );
              if (_param->_have_port_packet_id)
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_PACKET_ID"            ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_PACKET_ID"            );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_OPERATION"            ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_OPERATION"            );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_TYPE"                 ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_TYPE"                 );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_STORE_QUEUE_PTR_WRITE",
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_STORE_QUEUE_PTR_WRITE");
              if (_param->_have_port_load_queue_ptr)
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_LOAD_QUEUE_PTR_WRITE" ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_LOAD_QUEUE_PTR_WRITE" );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_HAS_IMMEDIAT"         ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_HAS_IMMEDIAT"         );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_IMMEDIAT"             ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_IMMEDIAT"             );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RA"              ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RA"              );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RB"              ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RB"              );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RC"              ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RC"              );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_WRITE_RD"             ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_WRITE_RD"             );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_NUM_REG_RD"           ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_NUM_REG_RD"           );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_WRITE_RE"             ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_WRITE_RE"             );
              PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_NUM_REG_RE"           ,
                                   dest,"out_READ_UNIT_OUT_"+toString(j               )+"_NUM_REG_RE"           );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_VAL"                  ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_VAL"                  );
+//           PORT_MAP(_component ,src ,"out_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_ACK"                  ,
+//                                dest, "in_READ_UNIT_OUT_"+toString(j               )+"_ACK"                  );
+//           if (_param->_have_port_context_id)
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_CONTEXT_ID"           ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_CONTEXT_ID"           );
+//           if (_param->_have_port_front_end_id)
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_FRONT_END_ID"         ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_FRONT_END_ID"         );
+//           if (_param->_have_port_ooo_engine_id)
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_OOO_ENGINE_ID"        ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_OOO_ENGINE_ID"        );
+//           if (_param->_have_port_rob_ptr  )
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_PACKET_ID"            ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_PACKET_ID"            );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_OPERATION"            ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_OPERATION"            );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_TYPE"                 ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_TYPE"                 );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_STORE_QUEUE_PTR_WRITE",
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_STORE_QUEUE_PTR_WRITE");
+//           if (_param->_have_port_load_queue_ptr)
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_LOAD_QUEUE_PTR_WRITE" ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_LOAD_QUEUE_PTR_WRITE" );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_HAS_IMMEDIAT"         ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_HAS_IMMEDIAT"         );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_IMMEDIAT"             ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_IMMEDIAT"             );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RA"              ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RA"              );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RB"              ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RB"              );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_DATA_RC"              ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_DATA_RC"              );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_WRITE_RD"             ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_WRITE_RD"             );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_NUM_REG_RD"           ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_NUM_REG_RD"           );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_WRITE_RE"             ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_WRITE_RE"             );
+//           PORT_MAP(_component ,src , "in_READ_UNIT_OUT_"+toString(it_read_unit_out)+"_NUM_REG_RE"           ,
+//                                dest,"out_READ_UNIT_OUT_"+toString(j               )+"_NUM_REG_RE"           );
              it_read_unit_out ++;
 …
 #endif
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_VAL"                  ,
                                     dest, "in_EXECUTE_IN_VAL"                  );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_IN_"+toString(i)+"_ACK"                  ,
                                     dest,"out_EXECUTE_IN_ACK"                  );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"           ,
                                     dest, "in_EXECUTE_IN_CONTEXT_ID"           );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_FRONT_END_ID"         ,
                                     dest, "in_EXECUTE_IN_FRONT_END_ID"         );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID"        ,
                                     dest, "in_EXECUTE_IN_OOO_ENGINE_ID"        );
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_PACKET_ID"            ,
                                     dest, "in_EXECUTE_IN_PACKET_ID"            );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OPERATION"            ,
                                     dest, "in_EXECUTE_IN_OPERATION"            );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_TYPE"                 ,
                                     dest, "in_EXECUTE_IN_TYPE"                 );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_STORE_QUEUE_PTR_WRITE",
                                     dest, "in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE");
                if (_param->_have_port_load_queue_ptr)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" ,
                                     dest, "in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE" );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_HAS_IMMEDIAT"         ,
                                     dest, "in_EXECUTE_IN_HAS_IMMEDIAT"         );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_IMMEDIAT"             ,
                                     dest, "in_EXECUTE_IN_IMMEDIAT"             );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RA"              ,
                                     dest, "in_EXECUTE_IN_DATA_RA"              );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RB"              ,
                                     dest, "in_EXECUTE_IN_DATA_RB"              );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RC"              ,
                                     dest, "in_EXECUTE_IN_DATA_RC"              );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RD"             ,
                                     dest, "in_EXECUTE_IN_WRITE_RD"             );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"           ,
                                     dest, "in_EXECUTE_IN_NUM_REG_RD"           );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RE"             ,
                                     dest, "in_EXECUTE_IN_WRITE_RE"             );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"           ,
                                     dest, "in_EXECUTE_IN_NUM_REG_RE"           );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_VAL"                  ,
+//                                  dest, "in_EXECUTE_IN_VAL"                  );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_IN_"+toString(i)+"_ACK"                  ,
+//                                  dest,"out_EXECUTE_IN_ACK"                  );
+//             if (_param->_have_port_context_id)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"           ,
+//                                  dest, "in_EXECUTE_IN_CONTEXT_ID"           );
+//             if (_param->_have_port_front_end_id)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_FRONT_END_ID"         ,
+//                                  dest, "in_EXECUTE_IN_FRONT_END_ID"         );
+//             if (_param->_have_port_ooo_engine_id)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID"        ,
+//                                  dest, "in_EXECUTE_IN_OOO_ENGINE_ID"        );
+//             if (_param->_have_port_rob_ptr  )
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_PACKET_ID"            ,
+//                                  dest, "in_EXECUTE_IN_PACKET_ID"            );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OPERATION"            ,
+//                                  dest, "in_EXECUTE_IN_OPERATION"            );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_TYPE"                 ,
+//                                  dest, "in_EXECUTE_IN_TYPE"                 );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_STORE_QUEUE_PTR_WRITE",
+//                                  dest, "in_EXECUTE_IN_STORE_QUEUE_PTR_WRITE");
+//             if (_param->_have_port_load_queue_ptr)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" ,
+//                                  dest, "in_EXECUTE_IN_LOAD_QUEUE_PTR_WRITE" );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_HAS_IMMEDIAT"         ,
+//                                  dest, "in_EXECUTE_IN_HAS_IMMEDIAT"         );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_IMMEDIAT"             ,
+//                                  dest, "in_EXECUTE_IN_IMMEDIAT"             );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RA"              ,
+//                                  dest, "in_EXECUTE_IN_DATA_RA"              );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RB"              ,
+//                                  dest, "in_EXECUTE_IN_DATA_RB"              );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RC"              ,
+//                                  dest, "in_EXECUTE_IN_DATA_RC"              );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RD"             ,
+//                                  dest, "in_EXECUTE_IN_WRITE_RD"             );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"           ,
+//                                  dest, "in_EXECUTE_IN_NUM_REG_RD"           );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RE"             ,
+//                                  dest, "in_EXECUTE_IN_WRITE_RE"             );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"           ,
+//                                  dest, "in_EXECUTE_IN_NUM_REG_RE"           );
+             }
            else
 …
 #endif
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_VAL"                  ,
                                     dest, "in_MEMORY_IN_VAL"                  );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_IN_"+toString(i)+"_ACK"                  ,
                                     dest,"out_MEMORY_IN_ACK"                  );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"           ,
                                     dest, "in_MEMORY_IN_CONTEXT_ID"           );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_FRONT_END_ID"         ,
                                     dest, "in_MEMORY_IN_FRONT_END_ID"         );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID"        ,
                                     dest, "in_MEMORY_IN_OOO_ENGINE_ID"        );
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_PACKET_ID"            ,
                                     dest, "in_MEMORY_IN_PACKET_ID"            );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OPERATION"            ,
                                     dest, "in_MEMORY_IN_OPERATION"            );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_TYPE"                 ,
                                     dest, "in_MEMORY_IN_TYPE"                 );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_STORE_QUEUE_PTR_WRITE",
                                     dest, "in_MEMORY_IN_STORE_QUEUE_PTR_WRITE");
                if (_param->_have_port_load_queue_ptr)
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" ,
                                     dest, "in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE" );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_HAS_IMMEDIAT"         ,
                                     dest, "in_MEMORY_IN_HAS_IMMEDIAT"         );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_IMMEDIAT"             ,
                                     dest, "in_MEMORY_IN_IMMEDIAT"             );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RA"              ,
                                     dest, "in_MEMORY_IN_DATA_RA"              );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RB"              ,
                                     dest, "in_MEMORY_IN_DATA_RB"              );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RC"              ,
                                     dest, "in_MEMORY_IN_DATA_RC"              );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RD"             ,
                                     dest, "in_MEMORY_IN_WRITE_RD"             );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"           ,
                                     dest, "in_MEMORY_IN_NUM_REG_RD"           );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RE"             ,
                                     dest, "in_MEMORY_IN_WRITE_RE"             );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"           ,
                                     dest, "in_MEMORY_IN_NUM_REG_RE"           );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_VAL"                  ,
+//                                  dest, "in_MEMORY_IN_VAL"                  );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_IN_"+toString(i)+"_ACK"                  ,
+//                                  dest,"out_MEMORY_IN_ACK"                  );
+//             if (_param->_have_port_context_id)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"           ,
+//                                  dest, "in_MEMORY_IN_CONTEXT_ID"           );
+//             if (_param->_have_port_front_end_id)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_FRONT_END_ID"         ,
+//                                  dest, "in_MEMORY_IN_FRONT_END_ID"         );
+//             if (_param->_have_port_ooo_engine_id)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID"        ,
+//                                  dest, "in_MEMORY_IN_OOO_ENGINE_ID"        );
+//             if (_param->_have_port_rob_ptr  )
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_PACKET_ID"            ,
+//                                  dest, "in_MEMORY_IN_PACKET_ID"            );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_OPERATION"            ,
+//                                  dest, "in_MEMORY_IN_OPERATION"            );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_TYPE"                 ,
+//                                  dest, "in_MEMORY_IN_TYPE"                 );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_STORE_QUEUE_PTR_WRITE",
+//                                  dest, "in_MEMORY_IN_STORE_QUEUE_PTR_WRITE");
+//             if (_param->_have_port_load_queue_ptr)
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_LOAD_QUEUE_PTR_WRITE" ,
+//                                  dest, "in_MEMORY_IN_LOAD_QUEUE_PTR_WRITE" );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_HAS_IMMEDIAT"         ,
+//                                  dest, "in_MEMORY_IN_HAS_IMMEDIAT"         );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_IMMEDIAT"             ,
+//                                  dest, "in_MEMORY_IN_IMMEDIAT"             );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RA"              ,
+//                                  dest, "in_MEMORY_IN_DATA_RA"              );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RB"              ,
+//                                  dest, "in_MEMORY_IN_DATA_RB"              );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_DATA_RC"              ,
+//                                  dest, "in_MEMORY_IN_DATA_RC"              );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RD"             ,
+//                                  dest, "in_MEMORY_IN_WRITE_RD"             );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"           ,
+//                                  dest, "in_MEMORY_IN_NUM_REG_RD"           );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_WRITE_RE"             ,
+//                                  dest, "in_MEMORY_IN_WRITE_RE"             );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"           ,
+//                                  dest, "in_MEMORY_IN_NUM_REG_RE"           );
+             }
+         }
 …
+     {
        src = _name+"_execution_unit_to_write_unit";
        std::cout << "Instance : " << src << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+       {
 …
                                           dest,"execute_out");
 #endif
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_VAL"          ,
                                     dest,"out_EXECUTE_OUT_VAL"          );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_ACK"          ,
                                     dest, "in_EXECUTE_OUT_ACK"          );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_CONTEXT_ID"   ,
                                     dest,"out_EXECUTE_OUT_CONTEXT_ID"   );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_FRONT_END_ID" ,
                                     dest,"out_EXECUTE_OUT_FRONT_END_ID" );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID",
                                     dest,"out_EXECUTE_OUT_OOO_ENGINE_ID");
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_PACKET_ID"    ,
                                     dest,"out_EXECUTE_OUT_PACKET_ID"    );
 //             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OPERATION"    ,
 //                                  dest,"out_EXECUTE_OUT_OPERATION"    );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_TYPE"         ,
                                     dest,"out_EXECUTE_OUT_TYPE"         );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RD"     ,
                                     dest,"out_EXECUTE_OUT_WRITE_RD"     );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RD"   ,
                                     dest,"out_EXECUTE_OUT_NUM_REG_RD"   );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RD"      ,
                                     dest,"out_EXECUTE_OUT_DATA_RD"      );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RE"     ,
                                     dest,"out_EXECUTE_OUT_WRITE_RE"     );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RE"   ,
                                     dest,"out_EXECUTE_OUT_NUM_REG_RE"   );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RE"      ,
                                     dest,"out_EXECUTE_OUT_DATA_RE"      );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_EXCEPTION"    ,
                                     dest,"out_EXECUTE_OUT_EXCEPTION"    );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NO_SEQUENCE"  ,
                                     dest,"out_EXECUTE_OUT_NO_SEQUENCE"  );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_ADDRESS"      ,
                                     dest,"out_EXECUTE_OUT_ADDRESS"      );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_VAL"          ,
+//                                  dest,"out_EXECUTE_OUT_VAL"          );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_ACK"          ,
+//                                  dest, "in_EXECUTE_OUT_ACK"          );
+//             if (_param->_have_port_context_id)
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_CONTEXT_ID"   ,
+//                                  dest,"out_EXECUTE_OUT_CONTEXT_ID"   );
+//             if (_param->_have_port_front_end_id)
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_FRONT_END_ID" ,
+//                                  dest,"out_EXECUTE_OUT_FRONT_END_ID" );
+//             if (_param->_have_port_ooo_engine_id)
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID",
+//                                  dest,"out_EXECUTE_OUT_OOO_ENGINE_ID");
+//             if (_param->_have_port_rob_ptr  )
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_PACKET_ID"    ,
+//                                  dest,"out_EXECUTE_OUT_PACKET_ID"    );
+// //          PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OPERATION"    ,
+// //                               dest,"out_EXECUTE_OUT_OPERATION"    );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_TYPE"         ,
+//                                  dest,"out_EXECUTE_OUT_TYPE"         );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RD"     ,
+//                                  dest,"out_EXECUTE_OUT_WRITE_RD"     );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RD"   ,
+//                                  dest,"out_EXECUTE_OUT_NUM_REG_RD"   );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RD"      ,
+//                                  dest,"out_EXECUTE_OUT_DATA_RD"      );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RE"     ,
+//                                  dest,"out_EXECUTE_OUT_WRITE_RE"     );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RE"   ,
+//                                  dest,"out_EXECUTE_OUT_NUM_REG_RE"   );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RE"      ,
+//                                  dest,"out_EXECUTE_OUT_DATA_RE"      );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_EXCEPTION"    ,
+//                                  dest,"out_EXECUTE_OUT_EXCEPTION"    );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NO_SEQUENCE"  ,
+//                                  dest,"out_EXECUTE_OUT_NO_SEQUENCE"  );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_ADDRESS"      ,
+//                                  dest,"out_EXECUTE_OUT_ADDRESS"      );
+             }
            else
 …
                                           dest,"memory_out");
 #endif
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_VAL"          ,
                                     dest,"out_MEMORY_OUT_VAL"          );
                PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_ACK"          ,
                                     dest, "in_MEMORY_OUT_ACK"          );
                if (_param->_have_port_context_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_CONTEXT_ID"   ,
                                     dest,"out_MEMORY_OUT_CONTEXT_ID"   );
                if (_param->_have_port_front_end_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_FRONT_END_ID" ,
                                     dest,"out_MEMORY_OUT_FRONT_END_ID" );
                if (_param->_have_port_ooo_engine_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID",
                                     dest,"out_MEMORY_OUT_OOO_ENGINE_ID");
                if (_param->_have_port_packet_id)
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_PACKET_ID"    ,
                                     dest,"out_MEMORY_OUT_PACKET_ID"    );
 //             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OPERATION"    ,
 //                                  dest,"out_MEMORY_OUT_OPERATION"    );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_TYPE"         ,
                                     dest,"out_MEMORY_OUT_TYPE"         );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RD"     ,
                                     dest,"out_MEMORY_OUT_WRITE_RD"     );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RD"   ,
                                     dest,"out_MEMORY_OUT_NUM_REG_RD"   );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RD"      ,
                                     dest,"out_MEMORY_OUT_DATA_RD"      );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RE"     ,
                                     dest,"out_MEMORY_OUT_WRITE_RE"     );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RE"   ,
                                     dest,"out_MEMORY_OUT_NUM_REG_RE"   );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RE"      ,
                                     dest,"out_MEMORY_OUT_DATA_RE"      );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_EXCEPTION"    ,
                                     dest,"out_MEMORY_OUT_EXCEPTION"    );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NO_SEQUENCE"  ,
                                     dest,"out_MEMORY_OUT_NO_SEQUENCE"  );
                PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_ADDRESS"      ,
                                     dest,"out_MEMORY_OUT_ADDRESS"      );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_VAL"          ,
+//                                  dest,"out_MEMORY_OUT_VAL"          );
+//             PORT_MAP(_component ,src ,"out_EXECUTE_UNIT_OUT_"+toString(i)+"_ACK"          ,
+//                                  dest, "in_MEMORY_OUT_ACK"          );
+//             if (_param->_have_port_context_id)
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_CONTEXT_ID"   ,
+//                                  dest,"out_MEMORY_OUT_CONTEXT_ID"   );
+//             if (_param->_have_port_front_end_id)
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_FRONT_END_ID" ,
+//                                  dest,"out_MEMORY_OUT_FRONT_END_ID" );
+//             if (_param->_have_port_ooo_engine_id)
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OOO_ENGINE_ID",
+//                                  dest,"out_MEMORY_OUT_OOO_ENGINE_ID");
+//             if (_param->_have_port_rob_ptr  )
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_PACKET_ID"    ,
+//                                  dest,"out_MEMORY_OUT_PACKET_ID"    );
+// //          PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_OPERATION"    ,
+// //                               dest,"out_MEMORY_OUT_OPERATION"    );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_TYPE"         ,
+//                                  dest,"out_MEMORY_OUT_TYPE"         );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RD"     ,
+//                                  dest,"out_MEMORY_OUT_WRITE_RD"     );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RD"   ,
+//                                  dest,"out_MEMORY_OUT_NUM_REG_RD"   );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RD"      ,
+//                                  dest,"out_MEMORY_OUT_DATA_RD"      );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_WRITE_RE"     ,
+//                                  dest,"out_MEMORY_OUT_WRITE_RE"     );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NUM_REG_RE"   ,
+//                                  dest,"out_MEMORY_OUT_NUM_REG_RE"   );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_DATA_RE"      ,
+//                                  dest,"out_MEMORY_OUT_DATA_RE"      );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_EXCEPTION"    ,
+//                                  dest,"out_MEMORY_OUT_EXCEPTION"    );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_NO_SEQUENCE"  ,
+//                                  dest,"out_MEMORY_OUT_NO_SEQUENCE"  );
+//             PORT_MAP(_component ,src , "in_EXECUTE_UNIT_OUT_"+toString(i)+"_ADDRESS"      ,
+//                                  dest,"out_MEMORY_OUT_ADDRESS"      );
+             }
+         }
 …
 #endif
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_VAL"          ,
                                 dest, "in_WRITE_UNIT_IN_VAL"          );
            PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_"+toString(i)+"_ACK"          ,
                                 dest,"out_WRITE_UNIT_IN_ACK"          );
            if (_param->_have_port_context_id)
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"   ,
                                 dest, "in_WRITE_UNIT_IN_CONTEXT_ID"   );
            if (_param->_have_port_front_end_id)
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_FRONT_END_ID" ,
                                 dest, "in_WRITE_UNIT_IN_FRONT_END_ID" );
            if (_param->_have_port_ooo_engine_id)
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID",
                                 dest, "in_WRITE_UNIT_IN_OOO_ENGINE_ID");
            if (_param->_have_port_packet_id)
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_PACKET_ID"    ,
                                 dest, "in_WRITE_UNIT_IN_PACKET_ID"    );
 //         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_OPERATION"    ,
 //                              dest, "in_WRITE_UNIT_IN_OPERATION"    );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_TYPE"         ,
                                 dest, "in_WRITE_UNIT_IN_TYPE"         );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RD"     ,
                                 dest, "in_WRITE_UNIT_IN_WRITE_RD"     );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"   ,
                                 dest, "in_WRITE_UNIT_IN_NUM_REG_RD"   );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RD"      ,
                                 dest, "in_WRITE_UNIT_IN_DATA_RD"      );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RE"     ,
                                 dest, "in_WRITE_UNIT_IN_WRITE_RE"     );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"   ,
                                 dest, "in_WRITE_UNIT_IN_NUM_REG_RE"   );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RE"      ,
                                 dest, "in_WRITE_UNIT_IN_DATA_RE"      );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_EXCEPTION"    ,
                                 dest, "in_WRITE_UNIT_IN_EXCEPTION"    );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_NO_SEQUENCE"  ,
                                 dest, "in_WRITE_UNIT_IN_NO_SEQUENCE"  );
            PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_ADDRESS"      ,
                                 dest, "in_WRITE_UNIT_IN_ADDRESS"      );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_VAL"          ,
+//                              dest, "in_WRITE_UNIT_IN_VAL"          );
+//         PORT_MAP(_component ,src , "in_WRITE_UNIT_IN_"+toString(i)+"_ACK"          ,
+//                              dest,"out_WRITE_UNIT_IN_ACK"          );
+//         if (_param->_have_port_context_id)
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_CONTEXT_ID"   ,
+//                              dest, "in_WRITE_UNIT_IN_CONTEXT_ID"   );
+//         if (_param->_have_port_front_end_id)
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_FRONT_END_ID" ,
+//                              dest, "in_WRITE_UNIT_IN_FRONT_END_ID" );
+//         if (_param->_have_port_ooo_engine_id)
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_OOO_ENGINE_ID",
+//                              dest, "in_WRITE_UNIT_IN_OOO_ENGINE_ID");
+//         if (_param->_have_port_rob_ptr  )
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_PACKET_ID"    ,
+//                              dest, "in_WRITE_UNIT_IN_PACKET_ID"    );
+// //      PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_OPERATION"    ,
+// //                           dest, "in_WRITE_UNIT_IN_OPERATION"    );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_TYPE"         ,
+//                              dest, "in_WRITE_UNIT_IN_TYPE"         );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RD"     ,
+//                              dest, "in_WRITE_UNIT_IN_WRITE_RD"     );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RD"   ,
+//                              dest, "in_WRITE_UNIT_IN_NUM_REG_RD"   );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RD"      ,
+//                              dest, "in_WRITE_UNIT_IN_DATA_RD"      );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_WRITE_RE"     ,
+//                              dest, "in_WRITE_UNIT_IN_WRITE_RE"     );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_NUM_REG_RE"   ,
+//                              dest, "in_WRITE_UNIT_IN_NUM_REG_RE"   );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_DATA_RE"      ,
+//                              dest, "in_WRITE_UNIT_IN_DATA_RE"      );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_EXCEPTION"    ,
+//                              dest, "in_WRITE_UNIT_IN_EXCEPTION"    );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_NO_SEQUENCE"  ,
+//                              dest, "in_WRITE_UNIT_IN_NO_SEQUENCE"  );
+//         PORT_MAP(_component ,src ,"out_WRITE_UNIT_IN_"+toString(i)+"_ADDRESS"      ,
+//                              dest, "in_WRITE_UNIT_IN_ADDRESS"      );
+         }
+     }
+#if DEBUG_Execute_loop == true
      _component->test_map();
+     for (uint32_t i=0; i<_param->_nb_read_unit; i++)
+       _component_read_unit [i]->_component->test_map();
+     for (uint32_t i=0; i<_param->_nb_functionnal_unit; i++)
+       _component_functionnal_unit [i]->_component->test_map();
+     for (uint32_t i=0; i<_param->_nb_load_store_unit; i++)
+       _component_load_store_unit [i]->_component->test_map();
+     for (uint32_t i=0; i<_param->_nb_write_unit; i++)
+       _component_write_unit [i]->_component->test_map();
+     _component_read_unit_to_execution_unit->_component->test_map();
+     _component_execution_unit_to_write_unit->_component->test_map();
+     _component_register_unit->_component->test_map();
+#ifdef POSITION
+    _component->generate_file();
+#endif
+#ifdef POSITION
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_deallocation.cpp

-              r81
+              r88
 /*
  * $Id$
 …
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Execute_loop.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 namespace behavioural {
 …
     log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
         delete     in_NRESET;
+        // ~~~~~[ Interface "execute_loop_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete []  in_EXECUTE_LOOP_IN_VAL                  ;
+        delete [] out_EXECUTE_LOOP_IN_ACK                  ;
+        if (_param->_have_port_context_id)
+        delete []  in_EXECUTE_LOOP_IN_CONTEXT_ID           ;
+        if (_param->_have_port_front_end_id)
+        delete []  in_EXECUTE_LOOP_IN_FRONT_END_ID         ;
+        if (_param->_have_port_ooo_engine_id)
+        delete []  in_EXECUTE_LOOP_IN_OOO_ENGINE_ID        ;
+        if (_param->_have_port_packet_id)
+        delete []  in_EXECUTE_LOOP_IN_PACKET_ID            ;
+        delete []  in_EXECUTE_LOOP_IN_OPERATION            ;
+        delete []  in_EXECUTE_LOOP_IN_TYPE                 ;
+        delete []  in_EXECUTE_LOOP_IN_STORE_QUEUE_PTR_WRITE;
+        if (_param->_have_port_load_queue_ptr)
+        delete []  in_EXECUTE_LOOP_IN_LOAD_QUEUE_PTR_WRITE ;
+        delete []  in_EXECUTE_LOOP_IN_HAS_IMMEDIAT         ;
+        delete []  in_EXECUTE_LOOP_IN_IMMEDIAT             ;
+        delete []  in_EXECUTE_LOOP_IN_READ_RA              ;
+        delete []  in_EXECUTE_LOOP_IN_NUM_REG_RA           ;
+        delete []  in_EXECUTE_LOOP_IN_READ_RB              ;
+        delete []  in_EXECUTE_LOOP_IN_NUM_REG_RB           ;
+        delete []  in_EXECUTE_LOOP_IN_READ_RC              ;
+        delete []  in_EXECUTE_LOOP_IN_NUM_REG_RC           ;
+        delete []  in_EXECUTE_LOOP_IN_WRITE_RD             ;
+        delete []  in_EXECUTE_LOOP_IN_NUM_REG_RD           ;
+        delete []  in_EXECUTE_LOOP_IN_WRITE_RE             ;
+        delete []  in_EXECUTE_LOOP_IN_NUM_REG_RE           ;
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_VAL                  ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_IN_ACK                  ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_CONTEXT_ID           ,_param->_nb_read_unit,_param->_size_context_id);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_FRONT_END_ID         ,_param->_nb_read_unit,_param->_size_front_end_id);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_OOO_ENGINE_ID        ,_param->_nb_read_unit,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_PACKET_ID            ,_param->_nb_read_unit,_param->_size_rob_ptr  );
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_OPERATION            ,_param->_nb_read_unit,_param->_size_operation);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_TYPE                 ,_param->_nb_read_unit,_param->_size_type);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_STORE_QUEUE_PTR_WRITE,_param->_nb_read_unit,_param->_size_store_queue_ptr);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_LOAD_QUEUE_PTR_WRITE ,_param->_nb_read_unit,_param->_size_load_queue_ptr);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_HAS_IMMEDIAT         ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_IMMEDIAT             ,_param->_nb_read_unit,_param->_size_general_data);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_READ_RA              ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RA           ,_param->_nb_read_unit,_param->_size_general_register);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_READ_RB              ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RB           ,_param->_nb_read_unit,_param->_size_general_register);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_READ_RC              ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RC           ,_param->_nb_read_unit,_param->_size_special_register);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_WRITE_RD             ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RD           ,_param->_nb_read_unit,_param->_size_general_register);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_WRITE_RE             ,_param->_nb_read_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_IN_NUM_REG_RE           ,_param->_nb_read_unit,_param->_size_special_register);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_VAL          ,_param->_nb_write_unit,1);
+        DELETE1_SIGNAL( in_EXECUTE_LOOP_OUT_ACK          ,_param->_nb_write_unit,1);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_CONTEXT_ID   ,_param->_nb_write_unit,_param->_size_context_id);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_FRONT_END_ID ,_param->_nb_write_unit,_param->_size_front_end_id);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_OOO_ENGINE_ID,_param->_nb_write_unit,_param->_size_ooo_engine_id);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_PACKET_ID    ,_param->_nb_write_unit,_param->_size_rob_ptr  );
+//      DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_OPERATION    ,_param->_nb_write_unit,_param->_size_operation);
+//      DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_TYPE         ,_param->_nb_write_unit,_param->_size_type);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_FLAGS        ,_param->_nb_write_unit,_param->_size_special_data);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_EXCEPTION    ,_param->_nb_write_unit,_param->_size_exception);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_NO_SEQUENCE  ,_param->_nb_write_unit,1);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_ADDRESS      ,_param->_nb_write_unit,_param->_size_general_data);
+        DELETE1_SIGNAL(out_EXECUTE_LOOP_OUT_DATA         ,_param->_nb_write_unit,_param->_size_general_data);
+        DELETE2_SIGNAL(out_DCACHE_REQ_VAL       , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],1                                  );
+        DELETE2_SIGNAL( in_DCACHE_REQ_ACK       , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],1                                  );
+        DELETE2_SIGNAL(out_DCACHE_REQ_CONTEXT_ID, _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_max_size_dcache_context_id);
+        DELETE2_SIGNAL(out_DCACHE_REQ_PACKET_ID , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_max_size_dcache_packet_id );
+        DELETE2_SIGNAL(out_DCACHE_REQ_ADDRESS   , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_size_general_data         );
+        DELETE2_SIGNAL(out_DCACHE_REQ_TYPE      , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_size_dcache_type          );
+        DELETE2_SIGNAL(out_DCACHE_REQ_WDATA     , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_size_general_data         );
+        DELETE2_SIGNAL( in_DCACHE_RSP_VAL       , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],1                                  );
+        DELETE2_SIGNAL(out_DCACHE_RSP_ACK       , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],1                                  );
+        DELETE2_SIGNAL( in_DCACHE_RSP_CONTEXT_ID, _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_max_size_dcache_context_id);
+        DELETE2_SIGNAL( in_DCACHE_RSP_PACKET_ID , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_max_size_dcache_packet_id );
+        DELETE2_SIGNAL( in_DCACHE_RSP_RDATA     , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_size_general_data         );
+        DELETE2_SIGNAL( in_DCACHE_RSP_ERROR     , _param->_nb_load_store_unit, _param->_nb_cache_port[it1],_param->_size_dcache_error         );
+        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_general_register);
+        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_special_register);
+//         DELETE2_SIGNAL( in_RETIRE_ROB_VAL           ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],1                             );
+//         DELETE2_SIGNAL(out_RETIRE_ROB_ACK           ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],1                             );
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RD_OLD_USE    ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],1                             );
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RD_OLD_NUM_REG,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],_param->_size_general_register);
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RD_NEW_USE    ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],1                             );
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RD_NEW_NUM_REG,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],_param->_size_general_register);
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RE_OLD_USE    ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],1                             );
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RE_OLD_NUM_REG,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],_param->_size_special_register);
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RE_NEW_USE    ,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],1                             );
+//         DELETE2_SIGNAL( in_RETIRE_ROB_RE_NEW_NUM_REG,_param->_nb_ooo_engine,_param->_nb_inst_retire_rob[it1],_param->_size_special_register);
+      }
-        // ~~~~~[ Interface "execute_loop_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        delete [] out_EXECUTE_LOOP_OUT_VAL                 ;
-        delete []  in_EXECUTE_LOOP_OUT_ACK                 ;
-        if (_param->_have_port_context_id)
-        delete [] out_EXECUTE_LOOP_OUT_CONTEXT_ID          ;
-        if (_param->_have_port_front_end_id)
-        delete [] out_EXECUTE_LOOP_OUT_FRONT_END_ID        ;
-        if (_param->_have_port_ooo_engine_id)
-        delete [] out_EXECUTE_LOOP_OUT_OOO_ENGINE_ID       ;
-        if (_param->_have_port_packet_id)
-        delete [] out_EXECUTE_LOOP_OUT_PACKET_ID           ;
-      //delete [] out_EXECUTE_LOOP_OUT_OPERATION           ;
-      //delete [] out_EXECUTE_LOOP_OUT_TYPE                ;
-        delete [] out_EXECUTE_LOOP_OUT_FLAGS               ;
-        delete [] out_EXECUTE_LOOP_OUT_EXCEPTION           ;
-        delete [] out_EXECUTE_LOOP_OUT_NO_SEQUENCE         ;
-        delete [] out_EXECUTE_LOOP_OUT_ADDRESS             ;
-        // ~~~~~[ Interface "dcache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        delete [] out_DCACHE_REQ_VAL                       ;
-        delete []  in_DCACHE_REQ_ACK                       ;
-        if (_param->_have_port_dcache_context_id)
-        delete [] out_DCACHE_REQ_CONTEXT_ID                ;
-        delete [] out_DCACHE_REQ_PACKET_ID                 ;
-        delete [] out_DCACHE_REQ_ADDRESS                   ;
-        delete [] out_DCACHE_REQ_TYPE                      ;
-        delete [] out_DCACHE_REQ_WDATA                     ;
-        // ~~~~~[ Interface "dcache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        delete []  in_DCACHE_RSP_VAL                       ;
-        delete [] out_DCACHE_RSP_ACK                       ;
-        if (_param->_have_port_dcache_context_id)
-        delete []  in_DCACHE_RSP_CONTEXT_ID                ;
-        delete []  in_DCACHE_RSP_PACKET_ID                 ;
-        delete []  in_DCACHE_RSP_RDATA                     ;
-        delete []  in_DCACHE_RSP_ERROR                     ;
-        // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        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                ;
-        // ~~~~~[ 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_OLD_NUM_REG            ;
-        delete []  in_RETIRE_ROB_RD_NEW_USE                ;
-        delete []  in_RETIRE_ROB_RD_NEW_NUM_REG            ;
-        delete []  in_RETIRE_ROB_RE_OLD_USE                ;
-        delete []  in_RETIRE_ROB_RE_OLD_NUM_REG            ;
-        delete []  in_RETIRE_ROB_RE_NEW_USE                ;
-        delete []  in_RETIRE_ROB_RE_NEW_NUM_REG            ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     delete    _component;
+    delete    _component_glue                        ;
     delete [] _component_read_unit                   ;
     delete [] _component_functionnal_unit            ;
     delete [] _component_load_store_unit             ;
     delete [] _component_write_unit                  ;
     delete [] _component_read_unit_to_execution_unit ;
     delete [] _component_execution_unit_to_write_unit;
     delete [] _component_register_unit               ;
+    delete    _component_read_unit_to_execution_unit ;
+    delete    _component_execution_unit_to_write_unit;
+    delete    _component_register_unit               ;
     log_printf(FUNC,Execute_loop,FUNCTION,"End");
 …
 }; // end namespace multi_execute_loop
 }; // end namespace core
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Execute_loop_statistics_declaration.cpp

r81	r88
37	37	_stat->add_stat(_component_execution_unit_to_write_unit->_stat);
38	38	_stat->add_stat(_component_register_unit ->_stat);
	39	_stat->add_stat(_component_glue ->_stat);
39	40
40	41	log_printf(FUNC,Execute_loop,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Parameters.h"
+#include "Common/include/Max.h"
 namespace morpheo {
 …
                           uint32_t              size_special_data                         ,
+                          uint32_t            * size_read_queue                           ,
+                          uint32_t            * size_reservation_station                  ,
+                          uint32_t            * nb_inst_retire                            ,
+                          uint32_t            * size_read_queue                           ,//[nb_read_unit]
+                          uint32_t            * size_reservation_station                  ,//[nb_read_unit]
+                          uint32_t            * nb_inst_retire                            ,//[nb_read_unit]
+                          uint32_t            * nb_inst_functionnal_unit                  ,//[nb_functionnal_unit]
+                          execute_timing_t  *** timing                                    ,//[nb_functionnal_unit][nb_type][nb_operation]
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                          execute_timing_t  *** timing                                    ,
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t),
+                          uint32_t            * size_store_queue                          ,
+                          uint32_t            * size_load_queue                           ,
+                          uint32_t            * size_speculative_access_queue             ,
+                          uint32_t            * nb_port_check                             ,
+                          Tspeculative_load_t * speculative_load                          ,
+                          uint32_t            * nb_bypass_memory                          ,
+                          uint32_t            * size_write_queue                          ,
+                          uint32_t            * size_execute_queue                        ,
+                          uint32_t            * nb_bypass_write                           ,
+                          uint32_t            * size_store_queue                          ,//[nb_load_store_unit]
+                          uint32_t            * size_load_queue                           ,//[nb_load_store_unit]
+                          uint32_t            * size_speculative_access_queue             ,//[nb_load_store_unit]
+                          uint32_t            * nb_port_check                             ,//[nb_load_store_unit]
+                          Tspeculative_load_t * speculative_load                          ,//[nb_load_store_unit]
+                          uint32_t            * nb_bypass_memory                          ,//[nb_load_store_unit]
+                          uint32_t            * nb_cache_port                             ,//[nb_load_store_unit]
+                          uint32_t            * nb_inst_memory                            ,//[nb_load_store_unit]
+                          uint32_t            * size_write_queue                          ,//[nb_write_unit]
+                          uint32_t            * size_execute_queue                        ,//[nb_write_unit]
+                          uint32_t            * nb_bypass_write                           ,//[nb_write_unit]
                           uint32_t              nb_gpr_bank                               ,
 …
                           uint32_t              nb_spr_port_read_by_bank                  ,
                           uint32_t              nb_spr_port_write_by_bank                 ,
                           uint32_t            * nb_general_register                       ,
                           uint32_t            * nb_special_register                       ,
                           uint32_t            * nb_inst_insert_rob                        ,
                           uint32_t            * nb_inst_retire_rob                        ,
+                          uint32_t            * nb_general_register                       ,//[nb_ooo_engine]
+                          uint32_t            * nb_special_register                       ,//[nb_ooo_engine]
+                          uint32_t            * nb_inst_insert_rob                        ,//[nb_ooo_engine]
+                          uint32_t            * nb_inst_retire_rob                        ,//[nb_ooo_engine]
                           Tpriority_t           execution_unit_to_write_unit_priority     ,
+                          bool               ** execution_unit_to_write_unit_table_routing,
+                          bool               ** execution_unit_to_write_unit_table_thread ,
+                          Tpriority_t           read_unit_to_execution_unit_priority      ,
+                          bool               ** read_unit_to_execution_unit_table_routing ,
+                          bool               ** read_unit_to_execution_unit_table_thread
+                          )
+                          bool              *** execution_unit_to_write_unit_table_routing,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
+                          bool               ** execution_unit_to_write_unit_table_thread ,//[nb_write_unit][nb_thread]
+                          Tpriority_t           read_unit_to_execution_unit_priority      ,
+                          bool              *** read_unit_to_execution_unit_table_routing ,//[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
+                          bool               ** read_unit_to_execution_unit_table_thread  ,//[nb_execute_unit][nb_thread]
+                          bool                * is_load_store_unit                        ,//[nb_execute_unit]
+                          uint32_t            * translate_num_execute_unit                ,//[nb_execute_unit]
+                          bool                  is_toplevel
+                          )
+  {
     log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
+    _nb_read_unit                          = nb_read_unit                         ;
+    _nb_functionnal_unit                   = nb_functionnal_unit                  ;
+    _nb_load_store_unit                    = nb_load_store_unit                   ;
+    _nb_write_unit                         = nb_write_unit                        ;
+    _nb_context                            = nb_context                           ;
+    _nb_front_end                          = nb_front_end                         ;
+    _nb_ooo_engine                         = nb_ooo_engine                        ;
+    _nb_packet                             = nb_packet                            ;
+    _size_general_data                     = size_general_data                    ;
+    _size_special_data                     = size_special_data                    ;
+    _size_read_queue                       = size_read_queue                      ;
+    _size_reservation_station              = size_reservation_station             ;
+    _nb_inst_retire                        = nb_inst_retire                       ;
+    _timing                                = timing                               ;
+    _get_custom_information                = get_custom_information               ;
+    _size_store_queue                      = size_store_queue                     ;
+    _size_load_queue                       = size_load_queue                      ;
+    _size_speculative_access_queue         = size_speculative_access_queue        ;
+    _nb_port_check                         = nb_port_check                        ;
+    _speculative_load                      = speculative_load                     ;
+    _nb_bypass_memory                      = nb_bypass_memory                     ;
+    _size_write_queue                      = size_write_queue                     ;
+    _size_execute_queue                    = size_execute_queue                   ;
+    _nb_bypass_write                       = nb_bypass_write                      ;
+    _nb_gpr_bank                           = nb_gpr_bank                          ;
+    _nb_gpr_port_read_by_bank              = nb_gpr_port_read_by_bank             ;
+    _nb_gpr_port_write_by_bank             = nb_gpr_port_write_by_bank            ;
+    _nb_spr_bank                           = nb_spr_bank                          ;
+    _nb_spr_port_read_by_bank              = nb_spr_port_read_by_bank             ;
+    _nb_spr_port_write_by_bank             = nb_spr_port_write_by_bank            ;
+    _nb_general_register                   = nb_general_register                  ;
+    _nb_special_register                   = nb_special_register                  ;
+    _nb_inst_insert_rob                    = nb_inst_insert_rob                   ;
+    _nb_inst_retire_rob                    = nb_inst_retire_rob                   ;
+    _nb_read_unit                               = nb_read_unit                         ;
+    _nb_functionnal_unit                        = nb_functionnal_unit                  ;
+    _nb_load_store_unit                         = nb_load_store_unit                   ;
+    _nb_write_unit                              = nb_write_unit                        ;
+    _nb_context                                 = nb_context                           ;
+    _nb_front_end                               = nb_front_end                         ;
+    _nb_ooo_engine                              = nb_ooo_engine                        ;
+    _nb_packet                                  = nb_packet                            ;
+    _size_read_queue                            = size_read_queue                      ;
+    _size_reservation_station                   = size_reservation_station             ;
+    _nb_inst_retire                             = nb_inst_retire                       ;
+    _nb_inst_functionnal_unit                   = nb_inst_functionnal_unit             ;
+    _timing                                     = timing                               ;
+    _get_custom_information                     = get_custom_information               ;
+    _size_store_queue                           = size_store_queue                     ;
+    _size_load_queue                            = size_load_queue                      ;
+    _size_speculative_access_queue              = size_speculative_access_queue        ;
+    _nb_port_check                              = nb_port_check                        ;
+    _speculative_load                           = speculative_load                     ;
+    _nb_bypass_memory                           = nb_bypass_memory                     ;
+    _nb_cache_port                              = nb_cache_port                        ;
+    _nb_inst_memory                             = nb_inst_memory                       ;
+    _size_write_queue                           = size_write_queue                     ;
+    _size_execute_queue                         = size_execute_queue                   ;
+    _nb_bypass_write                            = nb_bypass_write                      ;
+    _nb_gpr_bank                                = nb_gpr_bank                          ;
+    _nb_gpr_port_read_by_bank                   = nb_gpr_port_read_by_bank             ;
+    _nb_gpr_port_write_by_bank                  = nb_gpr_port_write_by_bank            ;
+    _nb_spr_bank                                = nb_spr_bank                          ;
+    _nb_spr_port_read_by_bank                   = nb_spr_port_read_by_bank             ;
+    _nb_spr_port_write_by_bank                  = nb_spr_port_write_by_bank            ;
+    _nb_general_register                        = nb_general_register                  ;
+    _nb_special_register                        = nb_special_register                  ;
+    _nb_inst_insert_rob                         = nb_inst_insert_rob                   ;
+    _nb_inst_retire_rob                         = nb_inst_retire_rob                   ;
     _execution_unit_to_write_unit_priority      = execution_unit_to_write_unit_priority;
 …
     _execution_unit_to_write_unit_table_thread  = execution_unit_to_write_unit_table_thread ;
     _read_unit_to_execution_unit_priority       = read_unit_to_execution_unit_priority ;
+    _read_unit_to_execution_unit_priority       = read_unit_to_execution_unit_priority      ;
     _read_unit_to_execution_unit_table_routing  = read_unit_to_execution_unit_table_routing ;
     _read_unit_to_execution_unit_table_thread   = read_unit_to_execution_unit_table_thread  ;
+    _nb_execute_unit                       = _nb_functionnal_unit + _nb_load_store_unit;
+    _size_context_id         = log2(nb_context            );
+    _size_front_end_id       = log2(nb_front_end          );
+    _size_ooo_engine_id      = log2(nb_ooo_engine         );
+    _size_packet_id          = log2(nb_packet             );
+    _have_port_context_id    = _size_context_id    >= 1;
+    _have_port_front_end_id  = _size_front_end_id  >= 1;
+    _have_port_ooo_engine_id = _size_ooo_engine_id >= 1;
+    _have_port_packet_id     = _size_packet_id     >= 1;
+    _is_load_store_unit         = new bool [_nb_execute_unit];
+    _translate_num_execute_unit = new uint32_t [_nb_execute_unit];
+    _is_load_store_unit                         = is_load_store_unit        ;
+    _translate_num_execute_unit                 = translate_num_execute_unit;
+    _nb_execute_unit                            = _nb_functionnal_unit + _nb_load_store_unit;
+    _nb_execute_unit_port                       = new uint32_t [_nb_execute_unit];
     _read_unit_to_execution_unit_table_execute_type = new bool * [_nb_execute_unit];
     for (uint32_t i=0; i<_nb_execute_unit; i++)
+      {
-        _is_load_store_unit [i] = false;
         _read_unit_to_execution_unit_table_execute_type [i] = new bool [_nb_type];
         for (uint32_t j=0; j<_nb_type; j++)
 …
     // Fill execute_type
     for (uint32_t i=0; i<_nb_execute_unit; i++)
+      for (uint32_t j=0; j<_nb_type; j++)
+        for (uint32_t k=0; k<_nb_operation; k++)
+          // Test if operation is implemnted
+          if (timing[i][j][k]._latence > 0)
+            {
+              _read_unit_to_execution_unit_table_execute_type [i][j] = true;
+              _is_load_store_unit [i] = (j == TYPE_MEMORY);
+              break;
+            }
+      // is load store
+      if (is_load_store_unit [i])
+        _read_unit_to_execution_unit_table_execute_type [i][TYPE_MEMORY] = true;
+      else
+        for (uint32_t j=0; j<_nb_type; j++)
+          if (is_type_valid (j))
+            for (uint32_t k=0; k<_nb_operation; k++)
+              {
+                uint32_t x = translate_num_execute_unit [i];
+                if (timing[x][j][k]._latence > 0)
+                  {
+                    log_printf(TRACE,Execute_loop,FUNCTION,"Execute unit '%d' (functional unit '%d') can execute type '%s'.",i,x,toString_type(j).c_str());
+                    _read_unit_to_execution_unit_table_execute_type [i][j] = true;
+                    break; // find an operation
+                  }
+              }
     for (uint32_t i=0; i<_nb_execute_unit; i++)
+      if (_is_load_store_unit [i])
+        log_printf(TRACE,Execute_loop,FUNCTION,"Execute unit '%d' is a Load Store  unit",i);
+      else
+        log_printf(TRACE,Execute_loop,FUNCTION,"Execute unit '%d' is a Functionnal unit",i);
+      {
+        uint32_t x = translate_num_execute_unit [i];
+        if (_is_load_store_unit [i])
+          _nb_execute_unit_port [i] = _nb_inst_memory [x];
+        else
+          _nb_execute_unit_port [i] = _nb_inst_functionnal_unit [x];
+      }
     _nb_gpr_read  = 2*_nb_read_unit;
 …
     _nb_spr_write = 1*_nb_write_unit;
+    _max_nb_general_register = 0;
+    _max_nb_special_register = 0;
+    for (uint32_t i=0; i<nb_ooo_engine; i++)
+      {
+        if (_nb_general_register[i] > _max_nb_general_register) _max_nb_general_register = _nb_general_register[i];
+        if (_nb_special_register[i] > _max_nb_special_register) _max_nb_special_register = _nb_special_register[i];
+      }
+    _max_size_store_queue    = 0;
+    _max_size_load_queue     = 0;
+    for (uint32_t i=0; i<nb_load_store_unit; i++)
+      {
+        if (_size_store_queue[i] > _max_size_store_queue) _max_size_store_queue = _size_store_queue[i];
+        if (_size_load_queue [i] > _max_size_load_queue ) _max_size_load_queue  = _size_load_queue [i];
+      }
+    _have_port_load_queue_ptr= _max_size_load_queue >= 2;
+    _size_general_register = log2(_max_nb_general_register);
+    _size_special_register = log2(_max_nb_special_register);
+    _max_nb_general_register = max<uint32_t>(nb_general_register,nb_ooo_engine);
+    _max_nb_special_register = max<uint32_t>(nb_special_register,nb_ooo_engine);
+    _max_size_store_queue    = max<uint32_t>(size_store_queue,nb_load_store_unit);
+    _max_size_load_queue     = max<uint32_t>(size_load_queue ,nb_load_store_unit);
     uint32_t _nb_thread = get_nb_thread(_nb_context,
 …
                                         _nb_ooo_engine);
+    uint32_t _max_nb_inst_memory = max<uint32_t>(_nb_inst_memory,_nb_load_store_unit);
     _set_read_unit_source_register_write = new std::set<uint32_t> [_nb_read_unit];
     _set_read_unit_source_bypass_write   = new std::set<uint32_t> [_nb_read_unit];
 …
     _read_unit_nb_bypass_memory           = new uint32_t [_nb_read_unit];
     _link_read_unit_with_load_store_unit  = new bool * [nb_read_unit];
     _link_read_unit_with_write_unit       = new bool * [nb_read_unit];
     _link_read_unit_with_thread           = new bool * [nb_read_unit];
+    _link_read_unit_with_load_store_unit  = new bool ** [nb_read_unit];
+    _link_read_unit_with_write_unit       = new bool *  [nb_read_unit];
+    _link_read_unit_with_thread           = new bool *  [nb_read_unit];
     for (uint32_t i=0; i<_nb_read_unit; i++)
 …
         _read_unit_nb_bypass_memory  [i] = 0;
         _link_read_unit_with_load_store_unit [i] = new bool [_nb_execute_unit];
         _link_read_unit_with_write_unit      [i] = new bool [_nb_write_unit];
         _link_read_unit_with_thread          [i] = new bool [_nb_thread];
+        _link_read_unit_with_load_store_unit [i] = new bool * [_nb_execute_unit];
+        _link_read_unit_with_write_unit      [i] = new bool   [_nb_write_unit];
+        _link_read_unit_with_thread          [i] = new bool   [_nb_thread];
         for (uint32_t j=0; j<_nb_execute_unit; j++)
+          _link_read_unit_with_load_store_unit [i][j] = false;
+          {
+            _link_read_unit_with_load_store_unit [i][j] = new bool [_max_nb_inst_memory];
+            for (uint32_t k=0; k<_max_nb_inst_memory; k++)
+              _link_read_unit_with_load_store_unit [i][j][k] = false;
+          }
         for (uint32_t j=0; j<_nb_write_unit; j++)
           _link_read_unit_with_write_unit [i][j] = false;
 …
         // fill link array
+        for (uint32_t j=0; j<_nb_execute_unit; j++)
+          {
+            // Test if this read unit can send operation at this execute_unit
+            if (_read_unit_to_execution_unit_table_routing [i][j])
+              {
+                if (_is_load_store_unit [j])
+                  {
+                    _link_read_unit_with_load_store_unit [i][j] = true;
+                  }
+                for (uint32_t k=0; k<_nb_thread; k++)
+                  {
+                    if (_read_unit_to_execution_unit_table_thread [j][k])
+                      {
+                        _link_read_unit_with_thread [i][k] = true;
+                      }
+                  }
+                // Scearch associed write_unit
+                for (uint32_t k=0; k<_nb_write_unit; k++)
+                  {
+                    // Test if this execute_unit can send operation at this write_unit
+                    // Test if have not a previous link ! (a same read_unit can send operation à two execute_unit and each execute_unit send at the same write_unit)
+                    if (_execution_unit_to_write_unit_table_routing [j][k] and
+                        not _link_read_unit_with_write_unit [i][k])
+                      // if yes : this write_unit can have operation sended by this read_unit
+                      {
+                        _link_read_unit_with_write_unit [i][k] = true;
+                      }
+                  }
+              }
+          }
+        for (uint32_t x=0; x<_nb_execute_unit; x++)
+          for (uint32_t y=0; y<_nb_execute_unit_port[x]; y++)
+            {
+              // Test if this read unit can send operation at this execute_unit
+              if (_read_unit_to_execution_unit_table_routing [i][x][y])
+                {
+                  if (_is_load_store_unit [x])
+                    {
+                      _link_read_unit_with_load_store_unit [i][x][y] = true;
+                    }
+                  for (uint32_t k=0; k<_nb_thread; k++)
+                    {
+                      if (_read_unit_to_execution_unit_table_thread [x][k])
+                        {
+                          _link_read_unit_with_thread [i][k] = true;
+                        }
+                    }
+                  // Scearch associed write_unit
+                  for (uint32_t k=0; k<_nb_write_unit; k++)
+                    {
+                      // Test if this execute_unit can send operation at this write_unit
+                      // Test if have not a previous link ! (a same read_unit can send operation à two execute_unit and each execute_unit send at the same write_unit)
+                      if (_execution_unit_to_write_unit_table_routing [x][y][k] and
+                          not _link_read_unit_with_write_unit [i][k])
+                        // if yes : this write_unit can have operation sended by this read_unit
+                        {
+                          _link_read_unit_with_write_unit [i][k] = true;
+                        }
+                    }
+                }
+            }
+      }
 …
+    std::cout << "_link_......." << std::endl;
+    std::cout << "_link_read_unit_with_load_store_unit" << std::endl;
+//     std::cout << "_link_......." << std::endl;
+//     std::cout << "_link_read_unit_with_load_store_unit" << std::endl;
+//     for (uint32_t i=0; i<_nb_read_unit; i++)
+//       {
+//      std::cout << "\t" << std::endl;
+//      for (uint32_t j=0; j<_nb_execute_unit; j++)
+//        for (uint32_t k=0; k<_nb_execute_unit_port[j]; k++)
+//          std::cout << _link_read_unit_with_load_store_unit [i][j][k] << " ";
+//      std::cout << std::endl;
+//       }
+//     std::cout << "_link_read_unit_with_write_unit" << std::endl;
+//     for (uint32_t i=0; i<_nb_read_unit; i++)
+//       {
+//      std::cout << "\t" << std::endl;
+//      for (uint32_t j=0; j<_nb_write_unit; j++)
+//        std::cout << _link_read_unit_with_write_unit [i][j] << " ";
+//      std::cout << std::endl;
+//       }
+//     std::cout << "_link_read_unit_with_thread" << std::endl;
+//     for (uint32_t i=0; i<_nb_read_unit; i++)
+//       {
+//      std::cout << "\t" << std::endl;
+//      for (uint32_t j=0; j<_nb_thread; j++)
+//        std::cout << _link_read_unit_with_thread [i][j] << " ";
+//      std::cout << std::endl;
+//       }
+//     std::cout << "_set_......." << std::endl;
     for (uint32_t i=0; i<_nb_read_unit; i++)
+      {
+        std::cout << "\t" << std::endl;
+        for (uint32_t j=0; j<_nb_execute_unit; j++)
+          std::cout << _link_read_unit_with_load_store_unit [i][j] << " ";
+        std::cout << std::endl;
+      }
+    std::cout << "_link_read_unit_with_write_unit" << std::endl;
+    for (uint32_t i=0; i<_nb_read_unit; i++)
+      {
+        std::cout << "\t" << std::endl;
+        for (uint32_t j=0; j<_nb_write_unit; j++)
+          std::cout << _link_read_unit_with_write_unit [i][j] << " ";
+        std::cout << std::endl;
+      }
+    std::cout << "_link_read_unit_with_thread" << std::endl;
+    for (uint32_t i=0; i<_nb_read_unit; i++)
+      {
+        std::cout << "\t" << std::endl;
+        for (uint32_t j=0; j<_nb_thread; j++)
+          std::cout << _link_read_unit_with_thread [i][j] << " ";
+        std::cout << std::endl;
+      }
+    std::cout << "_set_......." << std::endl;
+    for (uint32_t i=0; i<_nb_read_unit; i++)
+      {
+        std::cout << " * Read_unit[" << i << "]" << std::endl;
+//      std::cout << " * Read_unit[" << i << "]" << std::endl;
         for (uint32_t j=0; j<_nb_write_unit; j++)
+          {
             std::cout << "   * Write_unit[" << j << "]" << std::endl;
+//          std::cout << "   * Write_unit[" << j << "]" << std::endl;
             // Test the thread executed on this write_unit
             for (uint32_t k=0; k<_nb_thread; k++)
+              {
                 std::cout << "     * Thread[" << k << "]" << std::endl;
+//              std::cout << "     * Thread[" << k << "]" << std::endl;
                 if ( (_execution_unit_to_write_unit_table_thread [j][k]) and
                      (_link_read_unit_with_thread [i][k]))
+                  {
                     std::cout << "       * Find !!!!" << std::endl;
                     std::cout << "         * Read_unit "+toString(i)+" must take the gpr_write with write_unit "+toString(j)+"." << std::endl;
+//                  std::cout << "       * Find !!!!" << std::endl;
+//                  std::cout << "         * Read_unit "+toString(i)+" must take the gpr_write with write_unit "+toString(j)+"." << std::endl;
                     _set_read_unit_source_register_write[i].insert(j);
                     _read_unit_nb_register_write        [i] ++;
                     std::cout << "       * bypass_write : " << _nb_bypass_write [j] << std::endl;
                     std::cout << "         * Read_unit "+toString(i)+" must take the bypass_write with write_unit "+toString(j)+"." << std::endl;
+//                  std::cout << "       * bypass_write : " << _nb_bypass_write [j] << std::endl;
+//                  std::cout << "         * Read_unit "+toString(i)+" must take the bypass_write with write_unit "+toString(j)+"." << std::endl;
                     _set_read_unit_source_bypass_write  [i].insert(j);
                     _read_unit_nb_bypass_write          [i] += _nb_bypass_write [j];
 …
     for (uint32_t i=0; i<_nb_read_unit; i++)
+      {
         std::cout << " * Read_unit[" << i << "]" << std::endl;
+//      std::cout << " * Read_unit[" << i << "]" << std::endl;
         for (uint32_t j=0; j<_nb_execute_unit; j++)
+          {
+            std::cout << "   * Execute_unit[" << j << "]" << std::endl;
+            uint32_t x = translate_num_execute_unit [j];
+//          std::cout << "   * Execute_unit[" << j << "]" << std::endl;
             // Test the thread executed on this execute_unit
             for (uint32_t k=0; k<_nb_thread; k++)
+              {
                 std::cout << "     * Thread[" << k << "]" << std::endl;
+//              std::cout << "     * Thread[" << k << "]" << std::endl;
                 if ((_read_unit_to_execution_unit_table_thread [j][k]) and
                     (_link_read_unit_with_thread [i][k]) and
                     (_is_load_store_unit [j]))
+                  {
                     std::cout << "       * Find !!!!" << std::endl;
                     std::cout << "       * Bypass_memory !!!!" << std::endl;
                     std::cout << "         * Read_unit "+toString(i)+" must take the bypass_memory with load_store_unit "+toString(j)+"." << std::endl;
+//                  std::cout << "       * Find !!!!" << std::endl;
+//                  std::cout << "       * Bypass_memory !!!!" << std::endl;
+//                  std::cout << "         * Read_unit "+toString(i)+" must take the bypass_memory with load_store_unit "+toString(j)+"." << std::endl;
                     _set_read_unit_source_bypass_memory [i].insert(j);
+                    _read_unit_nb_bypass_memory         [i] += _nb_bypass_memory [j];
+                    break;
+                    _read_unit_nb_bypass_memory         [i] += _nb_bypass_memory [x];
+                    break; // loop on thread
+                  }
+              }
 …
+      }
+    uint32_t size_ooo_engine_id      = log2(nb_ooo_engine        );
+    uint32_t size_general_register   = log2(_max_nb_general_register);
+    uint32_t size_special_register   = log2(_max_nb_special_register);
     test();
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : glue");
+    _param_glue = new morpheo::behavioural::core::multi_execute_loop::execute_loop::execute_loop_glue::Parameters
+        (_nb_gpr_write              ,
+         _nb_spr_write              ,
+          size_ooo_engine_id        ,
+          size_general_register     ,
+          size_special_register     ,
+          size_general_data         ,
+          size_special_data         );
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit");
     _param_read_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters * [_nb_read_unit];
 …
          _nb_ooo_engine                    ,
          _nb_packet                        ,
          _size_general_data                ,
          _size_special_data                ,
+          size_general_data                ,
+          size_special_data                ,
          _max_nb_general_register          ,
          _max_nb_special_register          ,
 …
          _read_unit_nb_bypass_memory    [i]);
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execute_unit");
     _param_functionnal_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters * [_nb_functionnal_unit];
     _param_load_store_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters * [_nb_load_store_unit];
-    uint32_t x=0;
-    uint32_t y=0;
     for (uint32_t i=0; i<_nb_execute_unit; i++)
+      if (_is_load_store_unit [i] == false)
+        {
+          _translate_num_execute_unit [i] = x;
+      {
+        uint32_t x = _translate_num_execute_unit [i];
+        if (_is_load_store_unit [i] == false)
           _param_functionnal_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters
             (_nb_context                 ,
 …
              _nb_ooo_engine              ,
              _nb_packet                  ,
              _size_general_data          ,
+              size_general_data          ,
              _max_nb_general_register    ,
              _size_special_data          ,
+              size_special_data          ,
              _max_nb_special_register    ,
              _max_size_store_queue       ,
              _max_size_load_queue        ,
              _timing                  [i],
+             _timing                  [x],
              _get_custom_information     );
+          x++;
+        }
+      else
+        {
+          _translate_num_execute_unit [i] = y;
+          _param_load_store_unit [y] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters
+            (_size_store_queue              [y],
+             _size_load_queue               [y],
+             _size_speculative_access_queue [y],
+             _nb_port_check                 [y],
+             _speculative_load              [y],
+             _nb_bypass_memory              [y],
+        else
+          _param_load_store_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters
+            (_size_store_queue              [x],
+             _size_load_queue               [x],
+             _size_speculative_access_queue [x],
+             _nb_port_check                 [x],
+             _speculative_load              [x],
+             _nb_bypass_memory              [x],
+             _nb_cache_port                 [x],
+             _nb_inst_memory                [x],
              _nb_context                       ,
              _nb_front_end                     ,
              _nb_ooo_engine                    ,
              _nb_packet                        ,
              _size_general_data                ,
              _size_special_data                ,
+              size_general_data                ,
+              size_special_data                ,
              _max_nb_special_register          ,
              _max_nb_general_register          );
+          y ++;
+        }
+    for (uint32_t i=0; i<_nb_load_store_unit; i++)
+      }
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : write_unit");
     _param_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters * [_nb_write_unit];
     for (uint32_t i=0; i<_nb_write_unit; i++)
 …
          _nb_ooo_engine              ,
          _nb_packet                  ,
          _size_general_data          ,
+          size_general_data          ,
          _max_nb_general_register    ,
          _size_special_data          ,
+          size_special_data          ,
          _max_nb_special_register    ,
          _nb_bypass_write         [i]);
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit_to_execution_unit");
     _param_read_unit_to_execution_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
       (_nb_read_unit                                  ,
+       _nb_inst_retire                                ,
        _nb_execute_unit                               ,
+       _nb_execute_unit_port                          ,
        _nb_context                                    ,
        _nb_front_end                                  ,
        _nb_ooo_engine                                 ,
        _nb_packet                                     ,
        _size_general_data                             ,
        _size_special_data                             ,
+        size_general_data                             ,
+        size_special_data                             ,
        _max_nb_general_register                       ,
        _max_nb_special_register                       ,
 …
        _read_unit_to_execution_unit_table_thread      );
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execution_unit_to_write_unit");
     _param_execution_unit_to_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
       (_nb_execute_unit                           ,
+       _nb_execute_unit_port                      ,
        _nb_write_unit                             ,
        _nb_context                                ,
 …
        _nb_ooo_engine                             ,
        _nb_packet                                 ,
        _size_general_data                         ,
        _size_special_data                         ,
+        size_general_data                         ,
+        size_special_data                         ,
        _max_nb_general_register                   ,
        _max_nb_special_register                   ,
 …
        _execution_unit_to_write_unit_table_thread );
+    log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : register_unit");
     _param_register_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::Parameters
         (_nb_ooo_engine             ,
          _size_general_data         ,
          _size_special_data         ,
+          size_general_data         ,
+          size_special_data         ,
          _nb_gpr_read               ,
          _nb_gpr_write              ,
 …
          _nb_inst_retire_rob        );
     _max_size_dcache_context_id = 0;
     _max_size_dcache_packet_id  = 0;
 …
     _have_port_dcache_context_id = (_max_size_dcache_context_id>1);
+    if (is_toplevel)
+      {
+        _size_context_id         = log2(nb_context);
+        _size_front_end_id       = log2(nb_front_end);
+        _size_ooo_engine_id      = size_ooo_engine_id;
+        _size_rob_ptr            = log2(nb_packet);
+        _size_general_data       = size_general_data;
+        _size_special_data       = size_special_data;
+        _size_general_register   = size_general_register;
+        _size_special_register   = size_special_register;
+        _size_store_queue_ptr    = log2(_max_size_store_queue);
+        _size_load_queue_ptr     = log2(_max_size_load_queue );
+        _have_port_context_id    = _size_context_id     > 0;
+        _have_port_front_end_id  = _size_front_end_id   > 0;
+        _have_port_ooo_engine_id = _size_ooo_engine_id  > 0;
+        _have_port_rob_ptr       = _size_rob_ptr        > 0;
+        _have_port_load_queue_ptr= _size_load_queue_ptr > 0;
+        copy();
+      }
     log_printf(FUNC,Execute_loop,FUNCTION,"End");
 …
 #undef  FUNCTION
 #define FUNCTION "Execute_loop::~Parameters"
   Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
+    delete    _param_glue;
+    for (uint32_t i=0; i<_nb_read_unit; i++)
+      delete _param_read_unit [i];
     delete [] _param_read_unit;
+    for (uint32_t i=0; i<_nb_execute_unit; i++)
+      {
+        uint32_t x = _translate_num_execute_unit [i];
+        if (_is_load_store_unit [i] == false)
+          delete _param_functionnal_unit [x];
+        else
+          delete _param_load_store_unit [x];
+      }
     delete [] _param_functionnal_unit;
     delete [] _param_load_store_unit;
+    for (uint32_t i=0; i<_nb_write_unit; i++)
+      delete _param_write_unit [i];
     delete [] _param_write_unit;
     delete    _param_read_unit_to_execution_unit;
 …
     delete [] _is_load_store_unit;
     delete [] _translate_num_execute_unit;
+    delete [] _nb_execute_unit_port;
+    log_printf(FUNC,Execute_loop,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Execute_loop::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
+    COPY(_param_glue);
+    for (uint32_t i=0; i<_nb_read_unit; i++)
+      COPY(_param_read_unit [i]);
+    for (uint32_t i=0; i<_nb_execute_unit; i++)
+      {
+        uint32_t x = _translate_num_execute_unit [i];
+        if (_is_load_store_unit [i] == false)
+          COPY(_param_functionnal_unit [x]);
+        else
+          COPY(_param_load_store_unit [x]);
+      }
+    for (uint32_t i=0; i<_nb_write_unit; i++)
+      COPY(_param_write_unit [i]);
+    COPY(_param_read_unit_to_execution_unit);
+    COPY(_param_execution_unit_to_write_unit);
+    COPY(_param_register_unit);
     log_printf(FUNC,Execute_loop,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters_msg_error.cpp

-              r81
+              r88
     Parameters_test test ("Execute_loop");
+    for (uint32_t i=0; i<_nb_functionnal_unit; i++)
+      if (_nb_inst_functionnal_unit [i] != 1)
+        test.error(toString(_("Functionnal_unit [%d] must treat once instruction.\n"),i));
     log_printf(FUNC,Execute_loop,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters_print.cpp

-              r81
+              r88
         xml. singleton_begin("speculative_load             "); xml.attribut("value",toString(_speculative_load             [i])); xml.singleton_end();
         xml. singleton_begin("nb_bypass_memory             "); xml.attribut("value",toString(_nb_bypass_memory             [i])); xml.singleton_end();
+        xml. singleton_begin("nb_cache_port                "); xml.attribut("value",toString(_nb_cache_port                [i])); xml.singleton_end();
+        xml. singleton_begin("nb_inst_memory               "); xml.attribut("value",toString(_nb_inst_memory               [i])); xml.singleton_end();
         xml.balise_close();
+      }
 …
     str += _param_execution_unit_to_write_unit->print(depth+1);
     str += _param_register_unit->print(depth+1);
+    str += _param_glue->print(depth+1);
     xml.comment("\n"+str);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/Makefile

r83	r88
24	24	library_clean : Context_State_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/config_min.cfg

-              r83
+              r88
        1       +1      # nb_context
        1       +1      # nb_decod_unit
-       1       +1      # nb_ooo_engine
        1       +1      # nb_inst_branch_complete
        0       +1      # size_depth                    [0] [nb_context]
       30      +1      # size_address
        1       +1      # size_inst_decod               [0] [nb_decod_unit]
        1       +1      # size_inst_commit              [0] [nb_ooo_engine]
+       1       +1      # size_inst_commit
        0       +1      # link_context_to_decod_unit    [0] [nb_context]
-       0       +1      # link_decod_unit_to_ooo_engine [0] [nb_decod_unit]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/config_mono_context.cfg

-              r83
+              r88
        1       +1      # nb_context
        1       *4      # nb_decod_unit
-       1       *4      # nb_ooo_engine
        4       *4      # nb_inst_branch_complete
        2       +1      # size_depth                    [0] [nb_context]
       30      +1      # size_address
        4       *4      # size_inst_decod               [0] [nb_decod_unit]
        4       *4      # size_inst_commit              [0] [nb_ooo_engine]
+       4       *4      # size_inst_commit
        0       +1      # link_context_to_decod_unit    [0] [nb_context]
-       0       +1      # link_decod_unit_to_ooo_engine [0] [nb_decod_unit]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/config_multi_context.cfg

-              r83
+              r88
        8       +1      # nb_context
        4       *4      # nb_decod_unit
-       2       *4      # nb_ooo_engine
        2       *4      # nb_inst_branch_complete
        4       +1      # size_depth                    [0] [nb_context]
 …
        2       *4      # size_inst_decod               [2] [nb_decod_unit]
        4       *4      # size_inst_decod               [3] [nb_decod_unit]
+       8       *4      # size_inst_commit              [0] [nb_ooo_engine]
+       2       *4      # size_inst_commit              [1] [nb_ooo_engine]
+       8       *4      # size_inst_commit
        0       +1      # link_context_to_decod_unit    [0] [nb_context]
        1       +1      # link_context_to_decod_unit    [1] [nb_context]
 …
        2       +1      # link_context_to_decod_unit    [6] [nb_context]
        3       +1      # link_context_to_decod_unit    [7] [nb_context]
-       0       +1      # link_decod_unit_to_ooo_engine [0] [nb_decod_unit]
-       1       +1      # link_decod_unit_to_ooo_engine [1] [nb_decod_unit]
-       0       +1      # link_decod_unit_to_ooo_engine [2] [nb_decod_unit]
-       1       +1      # link_decod_unit_to_ooo_engine [3] [nb_decod_unit]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/src/main.cpp

-              r83
+              r88
   err (_(" * nb_context                                    (uint32_t)\n"));
   err (_(" * nb_decod_unit                                 (uint32_t)\n"));
-  err (_(" * nb_ooo_engine                                 (uint32_t)\n"));
   err (_(" * nb_inst_branch_complete                       (uint32_t)\n"));
   err (_(" * size_depth                    [nb_context]    (uint32_t)\n"));
   err (_(" * size_address                                  (uint32_t)\n"));
   err (_(" * size_inst_decod               [nb_decod_unit] (uint32_t)\n"));
   err (_(" * size_inst_commit              [nb_ooo_engine] (uint32_t)\n"));
+  err (_(" * size_inst_commit                              (uint32_t)\n"));
   err (_(" * link_context_to_decod_unit    [nb_context]    (uint32_t)\n"));
-  err (_(" * link_decod_unit_to_ooo_engine [nb_decod_unit] (uint32_t)\n"));
   exit (1);
 …
   uint32_t   _nb_context              = fromString<uint32_t>(argv[x++]);
   uint32_t   _nb_decod_unit           = fromString<uint32_t>(argv[x++]);
-  uint32_t   _nb_ooo_engine           = fromString<uint32_t>(argv[x++]);
   uint32_t   _nb_inst_branch_complete = fromString<uint32_t>(argv[x++]);
   if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context+2*_nb_decod_unit+1*_nb_ooo_engine))
+  if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context+1*_nb_decod_unit))
     usage (argc, argv);
 …
   for (uint32_t i=0; i<_nb_decod_unit; i++)
     _size_inst_decod [i] = fromString<uint32_t>(argv[x++]);
+  uint32_t * _size_inst_commit              = new uint32_t [_nb_ooo_engine];
+  for (uint32_t i=0; i<_nb_ooo_engine; i++)
+    _size_inst_commit [i] = fromString<uint32_t>(argv[x++]);
+  uint32_t   _size_inst_commit              = fromString<uint32_t>(argv[x++]);
   uint32_t * _link_context_to_decod_unit    = new uint32_t [_nb_context];
   for (uint32_t i=0; i<_nb_context; i++)
     _link_context_to_decod_unit [i] = fromString<uint32_t>(argv[x++]);
-  uint32_t * _link_decod_unit_to_ooo_engine = new uint32_t [_nb_decod_unit];
-  for (uint32_t i=0; i<_nb_decod_unit; i++)
-    _link_decod_unit_to_ooo_engine [i] = fromString<uint32_t>(argv[x++]);
   int _return = EXIT_SUCCESS;
 …
         (_nb_context                   ,
          _nb_decod_unit                ,
-         _nb_ooo_engine                ,
          _nb_inst_branch_complete      ,
          _size_depth                   ,
 …
          _size_inst_commit             ,
          _link_context_to_decod_unit   ,
          _link_decod_unit_to_ooo_engine
+         true
          );
 …
   delete [] _size_depth;
   delete [] _size_inst_decod;
-  delete [] _size_inst_commit;
   delete [] _link_context_to_decod_unit;
-  delete [] _link_decod_unit_to_ooo_engine;
   try

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/SelfTest/src/test.cpp

-              r83
+              r88
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
+  ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_VAL               ," in_BRANCH_EVENT_VAL               ",Tcontrol_t   ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_BRANCH_EVENT_ACK               ,"out_BRANCH_EVENT_ACK               ",Tcontrol_t   ,_param->_nb_context);
+//ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_CONTEXT_ID        ," in_BRANCH_EVENT_CONTEXT_ID        ",Tcontext_t   ,_param->_nb_context);
+//ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_DEPTH             ," in_BRANCH_EVENT_DEPTH             ",Tdepth_t     ,_param->_nb_context);
+//ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_MISS_PREDICTION   ," in_BRANCH_EVENT_MISS_PREDICTION   ",Tcontrol_t   ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_SRC       ," in_BRANCH_EVENT_ADDRESS_SRC       ",Taddress_t   ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST      ," in_BRANCH_EVENT_ADDRESS_DEST      ",Taddress_t   ,_param->_nb_context);
   ALLOC1_SC_SIGNAL( in_DECOD_EVENT_VAL                ," in_DECOD_EVENT_VAL                ",Tcontrol_t   ,_param->_nb_decod_unit);
   ALLOC1_SC_SIGNAL(out_DECOD_EVENT_ACK                ,"out_DECOD_EVENT_ACK                ",Tcontrol_t   ,_param->_nb_decod_unit);
 …
   ALLOC1_SC_SIGNAL( in_DECOD_EVENT_ADDRESS_EPCR       ," in_DECOD_EVENT_ADDRESS_EPCR       ",Taddress_t   ,_param->_nb_decod_unit);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_VAL               ," in_COMMIT_EVENT_VAL               ",Tcontrol_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL(out_COMMIT_EVENT_ACK               ,"out_COMMIT_EVENT_ACK               ",Tcontrol_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_CONTEXT_ID        ," in_COMMIT_EVENT_CONTEXT_ID        ",Tcontext_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_DEPTH             ," in_COMMIT_EVENT_DEPTH             ",Tdepth_t     ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_TYPE              ," in_COMMIT_EVENT_TYPE              ",Tevent_type_t,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_IS_DELAY_SLOT     ," in_COMMIT_EVENT_IS_DELAY_SLOT     ",Tcontrol_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS           ," in_COMMIT_EVENT_ADDRESS           ",Taddress_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS_EPCR      ," in_COMMIT_EVENT_ADDRESS_EPCR      ",Taddress_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS_EEAR_VAL  ," in_COMMIT_EVENT_ADDRESS_EEAR_VAL  ",Tcontrol_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS_EEAR      ," in_COMMIT_EVENT_ADDRESS_EEAR      ",Taddress_t   ,_param->_nb_ooo_engine);
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_VAL               ," in_COMMIT_EVENT_VAL               ",Tcontrol_t   );
+  ALLOC_SC_SIGNAL (out_COMMIT_EVENT_ACK               ,"out_COMMIT_EVENT_ACK               ",Tcontrol_t   );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_CONTEXT_ID        ," in_COMMIT_EVENT_CONTEXT_ID        ",Tcontext_t   );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_DEPTH             ," in_COMMIT_EVENT_DEPTH             ",Tdepth_t     );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_TYPE              ," in_COMMIT_EVENT_TYPE              ",Tevent_type_t);
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_IS_DELAY_SLOT     ," in_COMMIT_EVENT_IS_DELAY_SLOT     ",Tcontrol_t   );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS           ," in_COMMIT_EVENT_ADDRESS           ",Taddress_t   );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EPCR      ," in_COMMIT_EVENT_ADDRESS_EPCR      ",Taddress_t   );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EEAR_VAL  ," in_COMMIT_EVENT_ADDRESS_EEAR_VAL  ",Tcontrol_t   );
+  ALLOC_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EEAR      ," in_COMMIT_EVENT_ADDRESS_EEAR      ",Taddress_t   );
   ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_VAL            ," in_BRANCH_COMPLETE_VAL            ",Tcontrol_t   ,_param->_nb_inst_branch_complete);
 …
   ALLOC1_SC_SIGNAL( in_NB_INST_DECOD_ALL              ," in_NB_INST_DECOD_ALL              ",Tcounter_t   ,_param->_nb_decod_unit);
   ALLOC1_SC_SIGNAL( in_NB_INST_COMMIT_ALL             ," in_NB_INST_COMMIT_ALL             ",Tcounter_t   ,_param->_nb_ooo_engine);
   ALLOC1_SC_SIGNAL( in_NB_INST_COMMIT_MEM             ," in_NB_INST_COMMIT_MEM             ",Tcounter_t   ,_param->_nb_ooo_engine);
+  ALLOC1_SC_SIGNAL( in_NB_INST_DECOD_ALL              ," in_NB_INST_DECOD_ALL              ",Tcounter_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_NB_INST_COMMIT_ALL             ," in_NB_INST_COMMIT_ALL             ",Tcounter_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_NB_INST_COMMIT_MEM             ," in_NB_INST_COMMIT_MEM             ",Tcounter_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_EVENT_VAL                      ,"out_EVENT_VAL                      ",Tcontrol_t   ,_param->_nb_context   );
 …
   ALLOC1_SC_SIGNAL(out_EVENT_IS_DS_TAKE               ,"out_EVENT_IS_DS_TAKE               ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_SPR_VAL                        ,"out_SPR_VAL                        ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL( in_SPR_ACK                        ," in_SPR_ACK                        ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_SPR_EPCR                       ,"out_SPR_EPCR                       ",Taddress_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_SPR_EEAR                       ,"out_SPR_EEAR                       ",Taddress_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_SPR_EEAR_WEN                   ,"out_SPR_EEAR_WEN                   ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_SPR_SR_DSX                     ,"out_SPR_SR_DSX                     ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_SPR_SR_TO_ESR                  ,"out_SPR_SR_TO_ESR                  ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL(out_SPR_EVENT_VAL                  ,"out_SPR_EVENT_VAL                  ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_SPR_EVENT_ACK                  ," in_SPR_EVENT_ACK                  ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL(out_SPR_EVENT_EPCR                 ,"out_SPR_EVENT_EPCR                 ",Taddress_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL(out_SPR_EVENT_EEAR                 ,"out_SPR_EVENT_EEAR                 ",Taddress_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL(out_SPR_EVENT_EEAR_WEN             ,"out_SPR_EVENT_EEAR_WEN             ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL(out_SPR_EVENT_SR_DSX               ,"out_SPR_EVENT_SR_DSX               ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL(out_SPR_EVENT_SR_TO_ESR            ,"out_SPR_EVENT_SR_TO_ESR            ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL(out_CONTEXT_DECOD_ENABLE           ,"out_CONTEXT_DECOD_ENABLE           ",Tcontrol_t   ,_param->_nb_context   );
   ALLOC1_SC_SIGNAL( in_DEPTH_TAIL                     ," in_DEPTH_TAIL                     ",Tdepth_t     ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_DEPTH_MIN                      ," in_DEPTH_MIN                      ",Tdepth_t     ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_SPR_SR_IEE                     ," in_SPR_SR_IEE                     ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_SPR_SR_EPH                     ," in_SPR_SR_EPH                     ",Tcontrol_t   ,_param->_nb_context   );
+  ALLOC1_SC_SIGNAL( in_INTERRUPT_ENABLE               ," in_INTERRUPT_ENABLE               ",Tcontrol_t   ,_param->_nb_context   );
   /********************************************************
    * Instanciation
 …
   (*(_Context_State->in_NRESET))       (*(in_NRESET));
+  INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_VAL               ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Context_State,out_BRANCH_EVENT_ACK               ,_param->_nb_context);
+//INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_CONTEXT_ID        ,_param->_nb_context);
+//INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_DEPTH             ,_param->_nb_context);
+//INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_MISS_PREDICTION   ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_ADDRESS_SRC       ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_EVENT_ADDRESS_DEST      ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Context_State, in_DECOD_EVENT_VAL                ,_param->_nb_decod_unit);
   INSTANCE1_SC_SIGNAL(_Context_State,out_DECOD_EVENT_ACK                ,_param->_nb_decod_unit);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Context_State, in_DECOD_EVENT_CONTEXT_ID         ,_param->_nb_decod_unit);
   if (_param->_have_port_max_depth)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Context_State, in_DECOD_EVENT_DEPTH              ,_param->_nb_decod_unit);
   INSTANCE1_SC_SIGNAL(_Context_State, in_DECOD_EVENT_TYPE               ,_param->_nb_decod_unit);
 …
   INSTANCE1_SC_SIGNAL(_Context_State, in_DECOD_EVENT_ADDRESS_EPCR       ,_param->_nb_decod_unit);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_VAL               ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State,out_COMMIT_EVENT_ACK               ,_param->_nb_ooo_engine);
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_VAL               );
+  INSTANCE_SC_SIGNAL (_Context_State,out_COMMIT_EVENT_ACK               );
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_CONTEXT_ID        ,_param->_nb_ooo_engine);
   if (_param->_have_port_max_depth)
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_DEPTH             ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_TYPE              ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_IS_DELAY_SLOT     ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_ADDRESS           ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_ADDRESS_EPCR      ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_ADDRESS_EEAR_VAL  ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_COMMIT_EVENT_ADDRESS_EEAR      ,_param->_nb_ooo_engine);
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_CONTEXT_ID        );
+  if (_param->_have_port_depth)
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_DEPTH             );
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_TYPE              );
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_IS_DELAY_SLOT     );
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_ADDRESS           );
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_ADDRESS_EPCR      );
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_ADDRESS_EEAR_VAL  );
+  INSTANCE_SC_SIGNAL (_Context_State, in_COMMIT_EVENT_ADDRESS_EEAR      );
   INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_COMPLETE_VAL            ,_param->_nb_inst_branch_complete);
 …
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_COMPLETE_CONTEXT_ID     ,_param->_nb_inst_branch_complete);
   if (_param->_have_port_max_depth)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_COMPLETE_DEPTH          ,_param->_nb_inst_branch_complete);
   INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_COMPLETE_MISS_PREDICTION,_param->_nb_inst_branch_complete);
 …
   INSTANCE1_SC_SIGNAL(_Context_State, in_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete);
   INSTANCE1_SC_SIGNAL(_Context_State, in_NB_INST_DECOD_ALL              ,_param->_nb_decod_unit);
   INSTANCE1_SC_SIGNAL(_Context_State, in_NB_INST_COMMIT_ALL             ,_param->_nb_ooo_engine);
   INSTANCE1_SC_SIGNAL(_Context_State, in_NB_INST_COMMIT_MEM             ,_param->_nb_ooo_engine);
+  INSTANCE1_SC_SIGNAL(_Context_State, in_NB_INST_DECOD_ALL              ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State, in_NB_INST_COMMIT_ALL             ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State, in_NB_INST_COMMIT_MEM             ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_EVENT_VAL                      ,_param->_nb_context   );
 …
   INSTANCE1_SC_SIGNAL(_Context_State,out_EVENT_IS_DS_TAKE               ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_VAL                        ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State, in_SPR_ACK                        ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EPCR                       ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EEAR                       ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EEAR_WEN                   ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_SR_DSX                     ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_SR_TO_ESR                  ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EVENT_VAL                  ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State, in_SPR_EVENT_ACK                  ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EVENT_EPCR                 ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EVENT_EEAR                 ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EVENT_EEAR_WEN             ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EVENT_SR_DSX               ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State,out_SPR_EVENT_SR_TO_ESR            ,_param->_nb_context   );
   INSTANCE1_SC_SIGNAL(_Context_State,out_CONTEXT_DECOD_ENABLE           ,_param->_nb_context   );
   for (uint32_t i=0; i<_param->_nb_context; i++)
+    if (_param->_have_port_depth [i])
+      INSTANCE_SC_SIGNAL(_Context_State, in_DEPTH_TAIL [i]);
+    if (_param->_have_port_depth)
+      INSTANCE_SC_SIGNAL(_Context_State, in_DEPTH_MIN [i]);
+  INSTANCE1_SC_SIGNAL(_Context_State, in_SPR_SR_IEE                     ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State, in_SPR_SR_EPH                     ,_param->_nb_context   );
+  INSTANCE1_SC_SIGNAL(_Context_State, in_INTERRUPT_ENABLE               ,_param->_nb_context   );
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
       for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
         in_DECOD_EVENT_VAL [i]->write(0);
+      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+        in_COMMIT_EVENT_VAL [i]->write(0);
+      in_COMMIT_EVENT_VAL ->write(0);
       for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
         in_BRANCH_COMPLETE_VAL [i]->write(0);
 …
       for (uint32_t i=0; i<_param->_nb_context; i++)
+        {
+          in_EVENT_ACK [i]->write(0);
+          in_SPR_ACK   [i]->write(0);
+          in_BRANCH_EVENT_VAL [i]->write(0);
+          in_EVENT_ACK        [i]->write(0);
+          in_SPR_EVENT_ACK    [i]->write(0);
+          in_SPR_SR_IEE       [i]->write(0);
+          in_SPR_SR_EPH       [i]->write(0);
+          in_INTERRUPT_ENABLE [i]->write(0);
           TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[i]->read(), 1);
 …
       for (uint32_t i=0; i<_param->_nb_context; i++)
         if (_param->_have_port_depth [i])
           in_DEPTH_TAIL [i]->write(i%_param->_size_depth[i]);
+        if (_param->_have_port_depth)
+          in_DEPTH_MIN  [i]->write((_param->_array_size_depth[i]==0)?0:(i%_param->_array_size_depth[i]));
       uint32_t context    = rand()%_param->_nb_context;
-      uint32_t decod_unit = _param->_link_context_to_decod_unit    [context];
-      uint32_t ooo_engine = _param->_link_decod_unit_to_ooo_engine [decod_unit];
       if (1)
 …
           LABEL("msync (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
           uint32_t port = rand()%_param->_nb_decod_unit;
 …
           in_DECOD_EVENT_ADDRESS       [port]->write(0x100);
           in_DECOD_EVENT_ADDRESS_EPCR  [port]->write(0xdeadbeef);
           if (_param->_have_port_depth [context])
           in_DECOD_EVENT_DEPTH         [port]->write((context+1)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_DECOD_EVENT_DEPTH         [port]->write((_param->_array_size_depth[context]==0)?0:((context+1)%_param->_array_size_depth[context]));
           in_DECOD_EVENT_TYPE          [port]->write(EVENT_TYPE_MSYNC);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
           SC_START(1);
           LABEL("msync (wait end)");
           TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 0);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
           SC_START(3);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          SC_START(3);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
           TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
 …
           LABEL("psync (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
           uint32_t port = rand()%_param->_nb_decod_unit;
 …
           in_DECOD_EVENT_ADDRESS       [port]->write(0x200);
           in_DECOD_EVENT_ADDRESS_EPCR  [port]->write(0xdeadbebe);
           if (_param->_have_port_depth [context])
           in_DECOD_EVENT_DEPTH         [port]->write((context+1)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_DECOD_EVENT_DEPTH         [port]->write((_param->_array_size_depth[context]==0)?0:((context+1)%_param->_array_size_depth[context]));
           in_DECOD_EVENT_TYPE          [port]->write(EVENT_TYPE_PSYNC);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           LABEL("csync (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
           uint32_t port = rand()%_param->_nb_decod_unit;
 …
           in_DECOD_EVENT_ADDRESS       [port]->write(0x200);
           in_DECOD_EVENT_ADDRESS_EPCR  [port]->write(0xdeadbebe);
           if (_param->_have_port_depth [context])
           in_DECOD_EVENT_DEPTH         [port]->write((context+1)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_DECOD_EVENT_DEPTH         [port]->write((_param->_array_size_depth[context]==0)?0:((context+1)%_param->_array_size_depth[context]));
           in_DECOD_EVENT_TYPE          [port]->write(EVENT_TYPE_CSYNC);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           LABEL("spr (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
           uint32_t port = rand()%_param->_nb_decod_unit;
 …
           in_DECOD_EVENT_ADDRESS       [port]->write(0x100);
           in_DECOD_EVENT_ADDRESS_EPCR  [port]->write(0xdeadbeef);
           if (_param->_have_port_depth [context])
           in_DECOD_EVENT_DEPTH         [port]->write((context+1)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_DECOD_EVENT_DEPTH         [port]->write((_param->_array_size_depth[context]==0)?0:((context+1)%_param->_array_size_depth[context]));
           in_DECOD_EVENT_TYPE          [port]->write(EVENT_TYPE_SPR_ACCESS);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
           SC_START(1);
           LABEL("spr (wait end)");
           TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 0);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           SC_START(3);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          SC_START(3);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
           SC_START(1);
           TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
 …
           LABEL("miss (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
           uint32_t port = rand()%_param->_nb_inst_branch_complete;
           in_BRANCH_COMPLETE_CONTEXT_ID       [port]->write(context);
           if (_param->_have_port_depth [context])
           in_BRANCH_COMPLETE_DEPTH            [port]->write((context+1)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_BRANCH_COMPLETE_DEPTH            [port]->write((_param->_array_size_depth[context]==0)?0:((context+1)%_param->_array_size_depth[context]));
           in_BRANCH_COMPLETE_ADDRESS_SRC      [port]->write(0x400);
           in_BRANCH_COMPLETE_ADDRESS_DEST     [port]->write(0x500);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           LABEL("miss (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
           uint32_t port = rand()%_param->_nb_inst_branch_complete;
           in_BRANCH_COMPLETE_CONTEXT_ID       [port]->write(context);
           if (_param->_have_port_depth [context])
           in_BRANCH_COMPLETE_DEPTH            [port]->write((context+1)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_BRANCH_COMPLETE_DEPTH            [port]->write((_param->_array_size_depth[context]==0)?0:((context+1)%_param->_array_size_depth[context]));
           in_BRANCH_COMPLETE_ADDRESS_SRC      [port]->write(0x600);
           in_BRANCH_COMPLETE_ADDRESS_DEST     [port]->write(0x700);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           LABEL("exception (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
           uint32_t port = rand()%_param->_nb_ooo_engine;
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          uint32_t port = rand()%_param->_nb_decod_unit;
           in_DECOD_EVENT_CONTEXT_ID       [port]->write(context);
           if (_param->_have_port_depth [context])
           in_DECOD_EVENT_DEPTH            [port]->write((context)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_DECOD_EVENT_DEPTH            [port]->write((_param->_array_size_depth[context]==0)?0:((context)%_param->_array_size_depth[context]));
           in_DECOD_EVENT_TYPE             [port]->write(EVENT_TYPE_EXCEPTION);
           in_DECOD_EVENT_IS_DELAY_SLOT    [port]->write(0);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           do
+            {
               in_SPR_ACK [context]->write(rand()%percent_transaction_spr);
               SC_START(0);
               if (out_SPR_VAL [context]->read() and in_SPR_ACK [context]->read())
+                {
                   TEST(Taddress_t,out_SPR_EPCR      [context]->read(),0x900);
                 //TEST(Taddress_t,out_SPR_EEAR      [context]->read(),);
                   TEST(Tcontrol_t,out_SPR_EEAR_WEN  [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_DSX    [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_TO_ESR [context]->read(),1);
                   find = true;
+                }
               SC_START(1);
+            }
           while (not find);
           in_SPR_ACK [context]->write(0);
+              in_SPR_EVENT_ACK [context]->write(rand()%percent_transaction_spr);
+              SC_START(0);
+              if (out_SPR_EVENT_VAL [context]->read() and in_SPR_EVENT_ACK [context]->read())
+                {
+                  TEST(Taddress_t,out_SPR_EVENT_EPCR      [context]->read(),0x900);
+                //TEST(Taddress_t,out_SPR_EVENT_EEAR      [context]->read(),);
+                  TEST(Tcontrol_t,out_SPR_EVENT_EEAR_WEN  [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_DSX    [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_TO_ESR [context]->read(),1);
+                  find = true;
+                }
+              SC_START(1);
+            }
+          while (not find);
+          in_SPR_EVENT_ACK [context]->write(0);
+        }
 …
           LABEL("exception (begin)");
           in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
           uint32_t port = rand()%_param->_nb_ooo_engine;
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          uint32_t port = rand()%_param->_nb_decod_unit;
           in_DECOD_EVENT_CONTEXT_ID       [port]->write(context);
           if (_param->_have_port_depth [context])
           in_DECOD_EVENT_DEPTH            [port]->write((context)%_param->_size_depth[context]);
+          if (_param->_have_port_depth)
+          in_DECOD_EVENT_DEPTH            [port]->write((_param->_array_size_depth[context]==0)?0:((context)%_param->_array_size_depth[context]));
           in_DECOD_EVENT_TYPE             [port]->write(EVENT_TYPE_EXCEPTION);
           in_DECOD_EVENT_IS_DELAY_SLOT    [port]->write(1);
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           do
+            {
               in_SPR_ACK [context]->write(rand()%percent_transaction_spr);
               SC_START(0);
               if (out_SPR_VAL [context]->read() and in_SPR_ACK [context]->read())
+                {
                   TEST(Taddress_t,out_SPR_EPCR      [context]->read(),0x900);
                 //TEST(Taddress_t,out_SPR_EEAR      [context]->read(),);
                   TEST(Tcontrol_t,out_SPR_EEAR_WEN  [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_DSX    [context]->read(),1);
                   TEST(Tcontrol_t,out_SPR_SR_TO_ESR [context]->read(),1);
                   find = true;
+                }
               SC_START(1);
+            }
           while (not find);
           in_SPR_ACK [context]->write(0);
+              in_SPR_EVENT_ACK [context]->write(rand()%percent_transaction_spr);
+              SC_START(0);
+              if (out_SPR_EVENT_VAL [context]->read() and in_SPR_EVENT_ACK [context]->read())
+                {
+                  TEST(Taddress_t,out_SPR_EVENT_EPCR      [context]->read(),0x900);
+                //TEST(Taddress_t,out_SPR_EVENT_EEAR      [context]->read(),);
+                  TEST(Tcontrol_t,out_SPR_EVENT_EEAR_WEN  [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_DSX    [context]->read(),1);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_TO_ESR [context]->read(),1);
+                  find = true;
+                }
+              SC_START(1);
+            }
+          while (not find);
+          in_SPR_EVENT_ACK [context]->write(0);
+        }
 …
           LABEL("exception (begin)");
+          in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
+          in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
+          in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          uint32_t port = rand()%_param->_nb_ooo_engine;
+          in_COMMIT_EVENT_CONTEXT_ID       [port]->write(context);
+          if (_param->_have_port_depth [context])
+          in_COMMIT_EVENT_DEPTH            [port]->write((context)%_param->_size_depth[context]);
+          in_COMMIT_EVENT_TYPE             [port]->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    [port]->write(0);
+          in_COMMIT_EVENT_ADDRESS          [port]->write(0xa00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     [port]->write(0xb00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     [port]->write(0xc00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL [port]->write(0);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL [port]->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL [port]->read() and
+                       out_COMMIT_EVENT_ACK [port]->read()));
+          in_COMMIT_EVENT_VAL [port]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          in_COMMIT_EVENT_CONTEXT_ID       ->write(context);
+          if (_param->_have_port_depth)
+          in_COMMIT_EVENT_DEPTH            ->write((_param->_array_size_depth[context]==0)?0:((context)%_param->_array_size_depth[context]));
+          in_COMMIT_EVENT_TYPE             ->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    ->write(0);
+          in_COMMIT_EVENT_ADDRESS          ->write(0xa00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     ->write(0xb00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     ->write(0xc00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL ->write(0);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL ->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL ->read() and
+                       out_COMMIT_EVENT_ACK ->read()));
+          in_COMMIT_EVENT_VAL ->write(0);
           LABEL("exception (wait end)");
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           do
+            {
               in_SPR_ACK [context]->write(rand()%percent_transaction_spr);
               SC_START(0);
               if (out_SPR_VAL [context]->read() and in_SPR_ACK [context]->read())
+                {
                   TEST(Taddress_t,out_SPR_EPCR      [context]->read(),0xb00);
                   TEST(Taddress_t,out_SPR_EEAR      [context]->read(),0xc00);
                   TEST(Tcontrol_t,out_SPR_EEAR_WEN  [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_DSX    [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_TO_ESR [context]->read(),1);
                   find = true;
+                }
               SC_START(1);
+            }
           while (not find);
           in_SPR_ACK [context]->write(0);
+              in_SPR_EVENT_ACK [context]->write(rand()%percent_transaction_spr);
+              SC_START(0);
+              if (out_SPR_EVENT_VAL [context]->read() and in_SPR_EVENT_ACK [context]->read())
+                {
+                  TEST(Taddress_t,out_SPR_EVENT_EPCR      [context]->read(),0xb00);
+                  TEST(Taddress_t,out_SPR_EVENT_EEAR      [context]->read(),0xc00);
+                  TEST(Tcontrol_t,out_SPR_EVENT_EEAR_WEN  [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_DSX    [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_TO_ESR [context]->read(),1);
+                  find = true;
+                }
+              SC_START(1);
+            }
+          while (not find);
+          in_SPR_EVENT_ACK [context]->write(0);
+        }
 …
           LABEL("exception (begin)");
+          in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
+          in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
+          in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          uint32_t port = rand()%_param->_nb_ooo_engine;
+          in_COMMIT_EVENT_CONTEXT_ID       [port]->write(context);
+          if (_param->_have_port_depth [context])
+          in_COMMIT_EVENT_DEPTH            [port]->write((context)%_param->_size_depth[context]);
+          in_COMMIT_EVENT_TYPE             [port]->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    [port]->write(1);
+          in_COMMIT_EVENT_ADDRESS          [port]->write(0xd00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     [port]->write(0xe00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     [port]->write(0xf00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL [port]->write(0);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL [port]->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL [port]->read() and
+                       out_COMMIT_EVENT_ACK [port]->read()));
+          in_COMMIT_EVENT_VAL [port]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          in_COMMIT_EVENT_CONTEXT_ID       ->write(context);
+          if (_param->_have_port_depth)
+          in_COMMIT_EVENT_DEPTH            ->write((_param->_array_size_depth[context]==0)?0:((context)%_param->_array_size_depth[context]));
+          in_COMMIT_EVENT_TYPE             ->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    ->write(1);
+          in_COMMIT_EVENT_ADDRESS          ->write(0xd00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     ->write(0xe00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     ->write(0xf00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL ->write(0);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL ->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL ->read() and
+                       out_COMMIT_EVENT_ACK ->read()));
+          in_COMMIT_EVENT_VAL ->write(0);
           LABEL("exception (wait end)");
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           do
+            {
               in_SPR_ACK [context]->write(rand()%percent_transaction_spr);
               SC_START(0);
               if (out_SPR_VAL [context]->read() and in_SPR_ACK [context]->read())
+                {
                   TEST(Taddress_t,out_SPR_EPCR      [context]->read(),0xe00);
                   TEST(Taddress_t,out_SPR_EEAR      [context]->read(),0xf00);
                   TEST(Tcontrol_t,out_SPR_EEAR_WEN  [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_DSX    [context]->read(),1);
                   TEST(Tcontrol_t,out_SPR_SR_TO_ESR [context]->read(),1);
                   find = true;
+                }
               SC_START(1);
+            }
           while (not find);
           in_SPR_ACK [context]->write(0);
+              in_SPR_EVENT_ACK [context]->write(rand()%percent_transaction_spr);
+              SC_START(0);
+              if (out_SPR_EVENT_VAL [context]->read() and in_SPR_EVENT_ACK [context]->read())
+                {
+                  TEST(Taddress_t,out_SPR_EVENT_EPCR      [context]->read(),0xe00);
+                  TEST(Taddress_t,out_SPR_EVENT_EEAR      [context]->read(),0xf00);
+                  TEST(Tcontrol_t,out_SPR_EVENT_EEAR_WEN  [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_DSX    [context]->read(),1);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_TO_ESR [context]->read(),1);
+                  find = true;
+                }
+              SC_START(1);
+            }
+          while (not find);
+          in_SPR_EVENT_ACK [context]->write(0);
+        }
 …
           LABEL("exception (begin)");
+          in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
+          in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
+          in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          uint32_t port = rand()%_param->_nb_ooo_engine;
+          in_COMMIT_EVENT_CONTEXT_ID       [port]->write(context);
+          if (_param->_have_port_depth [context])
+          in_COMMIT_EVENT_DEPTH            [port]->write((context)%_param->_size_depth[context]);
+          in_COMMIT_EVENT_TYPE             [port]->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    [port]->write(0);
+          in_COMMIT_EVENT_ADDRESS          [port]->write(0xa00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     [port]->write(0xb00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     [port]->write(0xc00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL [port]->write(1);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL [port]->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL [port]->read() and
+                       out_COMMIT_EVENT_ACK [port]->read()));
+          in_COMMIT_EVENT_VAL [port]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          in_COMMIT_EVENT_CONTEXT_ID       ->write(context);
+          if (_param->_have_port_depth)
+          in_COMMIT_EVENT_DEPTH            ->write((_param->_array_size_depth[context]==0)?0:((context)%_param->_array_size_depth[context]));
+          in_COMMIT_EVENT_TYPE             ->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    ->write(0);
+          in_COMMIT_EVENT_ADDRESS          ->write(0xa00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     ->write(0xb00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     ->write(0xc00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL ->write(1);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL ->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL ->read() and
+                       out_COMMIT_EVENT_ACK ->read()));
+          in_COMMIT_EVENT_VAL ->write(0);
           LABEL("exception (wait end)");
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           do
+            {
               in_SPR_ACK [context]->write(rand()%percent_transaction_spr);
               SC_START(0);
               if (out_SPR_VAL [context]->read() and in_SPR_ACK [context]->read())
+                {
                   TEST(Taddress_t,out_SPR_EPCR      [context]->read(),0xb00);
                   TEST(Taddress_t,out_SPR_EEAR      [context]->read(),0xc00);
                   TEST(Tcontrol_t,out_SPR_EEAR_WEN  [context]->read(),1);
                   TEST(Tcontrol_t,out_SPR_SR_DSX    [context]->read(),0);
                   TEST(Tcontrol_t,out_SPR_SR_TO_ESR [context]->read(),1);
                   find = true;
+                }
               SC_START(1);
+            }
           while (not find);
           in_SPR_ACK [context]->write(0);
+              in_SPR_EVENT_ACK [context]->write(rand()%percent_transaction_spr);
+              SC_START(0);
+              if (out_SPR_EVENT_VAL [context]->read() and in_SPR_EVENT_ACK [context]->read())
+                {
+                  TEST(Taddress_t,out_SPR_EVENT_EPCR      [context]->read(),0xb00);
+                  TEST(Taddress_t,out_SPR_EVENT_EEAR      [context]->read(),0xc00);
+                  TEST(Tcontrol_t,out_SPR_EVENT_EEAR_WEN  [context]->read(),1);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_DSX    [context]->read(),0);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_TO_ESR [context]->read(),1);
+                  find = true;
+                }
+              SC_START(1);
+            }
+          while (not find);
+          in_SPR_EVENT_ACK [context]->write(0);
+        }
 …
           LABEL("exception (begin)");
+          in_NB_INST_DECOD_ALL  [decod_unit]->write(1);
+          in_NB_INST_COMMIT_ALL [ooo_engine]->write(1);
+          in_NB_INST_COMMIT_MEM [ooo_engine]->write(1);
+          uint32_t port = rand()%_param->_nb_ooo_engine;
+          in_COMMIT_EVENT_CONTEXT_ID       [port]->write(context);
+          if (_param->_have_port_depth [context])
+          in_COMMIT_EVENT_DEPTH            [port]->write((context)%_param->_size_depth[context]);
+          in_COMMIT_EVENT_TYPE             [port]->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    [port]->write(1);
+          in_COMMIT_EVENT_ADDRESS          [port]->write(0xd00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     [port]->write(0xe00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     [port]->write(0xf00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL [port]->write(1);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL [port]->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL [port]->read() and
+                       out_COMMIT_EVENT_ACK [port]->read()));
+          in_COMMIT_EVENT_VAL [port]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(1);
+          in_NB_INST_COMMIT_ALL [context]->write(1);
+          in_NB_INST_COMMIT_MEM [context]->write(1);
+          in_COMMIT_EVENT_CONTEXT_ID       ->write(context);
+          if (_param->_have_port_depth)
+          in_COMMIT_EVENT_DEPTH            ->write((_param->_array_size_depth[context]==0)?0:((context)%_param->_array_size_depth[context]));
+          in_COMMIT_EVENT_TYPE             ->write(EVENT_TYPE_EXCEPTION);
+          in_COMMIT_EVENT_IS_DELAY_SLOT    ->write(1);
+          in_COMMIT_EVENT_ADDRESS          ->write(0xd00);
+          in_COMMIT_EVENT_ADDRESS_EPCR     ->write(0xe00);
+          in_COMMIT_EVENT_ADDRESS_EEAR     ->write(0xf00);
+          in_COMMIT_EVENT_ADDRESS_EEAR_VAL ->write(1);
+          TEST(Tcontrol_t, out_CONTEXT_DECOD_ENABLE[context]->read(), 1);
+          do
+            {
+              in_COMMIT_EVENT_VAL ->write(rand()%percent_transaction_commit_event);
+              SC_START(1);
+            }
+          while (not ( in_COMMIT_EVENT_VAL ->read() and
+                       out_COMMIT_EVENT_ACK ->read()));
+          in_COMMIT_EVENT_VAL ->write(0);
           LABEL("exception (wait end)");
 …
           SC_START(3);
           in_NB_INST_DECOD_ALL  [decod_unit]->write(0);
           in_NB_INST_COMMIT_ALL [ooo_engine]->write(0);
           in_NB_INST_COMMIT_MEM [ooo_engine]->write(0);
+          in_NB_INST_DECOD_ALL  [context]->write(0);
+          in_NB_INST_COMMIT_ALL [context]->write(0);
+          in_NB_INST_COMMIT_MEM [context]->write(0);
           SC_START(1);
 …
           do
+            {
               in_SPR_ACK [context]->write(rand()%percent_transaction_spr);
               SC_START(0);
               if (out_SPR_VAL [context]->read() and in_SPR_ACK [context]->read())
+                {
                   TEST(Taddress_t,out_SPR_EPCR      [context]->read(),0xe00);
                   TEST(Taddress_t,out_SPR_EEAR      [context]->read(),0xf00);
                   TEST(Tcontrol_t,out_SPR_EEAR_WEN  [context]->read(),1);
                   TEST(Tcontrol_t,out_SPR_SR_DSX    [context]->read(),1);
                   TEST(Tcontrol_t,out_SPR_SR_TO_ESR [context]->read(),1);
                   find = true;
+                }
               SC_START(1);
+            }
           while (not find);
           in_SPR_ACK [context]->write(0);
+              in_SPR_EVENT_ACK [context]->write(rand()%percent_transaction_spr);
+              SC_START(0);
+              if (out_SPR_EVENT_VAL [context]->read() and in_SPR_EVENT_ACK [context]->read())
+                {
+                  TEST(Taddress_t,out_SPR_EVENT_EPCR      [context]->read(),0xe00);
+                  TEST(Taddress_t,out_SPR_EVENT_EEAR      [context]->read(),0xf00);
+                  TEST(Tcontrol_t,out_SPR_EVENT_EEAR_WEN  [context]->read(),1);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_DSX    [context]->read(),1);
+                  TEST(Tcontrol_t,out_SPR_EVENT_SR_TO_ESR [context]->read(),1);
+                  find = true;
+                }
+              SC_START(1);
+            }
+          while (not find);
+          in_SPR_EVENT_ACK [context]->write(0);
+        }
 …
   delete in_NRESET;
+  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_VAL               ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ACK               ,_param->_nb_context);
+//DELETE1_SC_SIGNAL( in_BRANCH_EVENT_CONTEXT_ID        ,_param->_nb_context);
+//DELETE1_SC_SIGNAL( in_BRANCH_EVENT_DEPTH             ,_param->_nb_context);
+//DELETE1_SC_SIGNAL( in_BRANCH_EVENT_MISS_PREDICTION   ,_param->_nb_context);
+  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_SRC       ,_param->_nb_context);
+  DELETE1_SC_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST      ,_param->_nb_context);
   DELETE1_SC_SIGNAL( in_DECOD_EVENT_VAL                ,_param->_nb_decod_unit);
   DELETE1_SC_SIGNAL(out_DECOD_EVENT_ACK                ,_param->_nb_decod_unit);
 …
   DELETE1_SC_SIGNAL( in_DECOD_EVENT_ADDRESS            ,_param->_nb_decod_unit);
   DELETE1_SC_SIGNAL( in_DECOD_EVENT_ADDRESS_EPCR       ,_param->_nb_decod_unit);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_VAL               ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL(out_COMMIT_EVENT_ACK               ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_CONTEXT_ID        ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_DEPTH             ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_TYPE              ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_IS_DELAY_SLOT     ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS           ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS_EPCR      ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS_EEAR_VAL  ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_COMMIT_EVENT_ADDRESS_EEAR      ,_param->_nb_ooo_engine);
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_VAL               );
+  DELETE_SC_SIGNAL (out_COMMIT_EVENT_ACK               );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_CONTEXT_ID        );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_DEPTH             );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_TYPE              );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_IS_DELAY_SLOT     );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS           );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EPCR      );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EEAR_VAL  );
+  DELETE_SC_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EEAR      );
   DELETE1_SC_SIGNAL( in_BRANCH_COMPLETE_VAL            ,_param->_nb_inst_branch_complete);
   DELETE1_SC_SIGNAL(out_BRANCH_COMPLETE_ACK            ,_param->_nb_inst_branch_complete);
 …
   DELETE1_SC_SIGNAL( in_BRANCH_COMPLETE_ADDRESS_SRC    ,_param->_nb_inst_branch_complete);
   DELETE1_SC_SIGNAL( in_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete);
   DELETE1_SC_SIGNAL( in_NB_INST_DECOD_ALL              ,_param->_nb_decod_unit);
   DELETE1_SC_SIGNAL( in_NB_INST_COMMIT_ALL             ,_param->_nb_ooo_engine);
   DELETE1_SC_SIGNAL( in_NB_INST_COMMIT_MEM             ,_param->_nb_ooo_engine);
+  DELETE1_SC_SIGNAL( in_NB_INST_DECOD_ALL              ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_NB_INST_COMMIT_ALL             ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_NB_INST_COMMIT_MEM             ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_EVENT_VAL                      ,_param->_nb_context   );
   DELETE1_SC_SIGNAL( in_EVENT_ACK                      ,_param->_nb_context   );
 …
   DELETE1_SC_SIGNAL(out_EVENT_ADDRESS_NEXT_VAL         ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_EVENT_IS_DS_TAKE               ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_SPR_VAL                        ,_param->_nb_context   );
   DELETE1_SC_SIGNAL( in_SPR_ACK                        ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_SPR_EPCR                       ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_SPR_EEAR                       ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_SPR_EEAR_WEN                   ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_SPR_SR_DSX                     ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_SPR_SR_TO_ESR                  ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL(out_SPR_EVENT_VAL                  ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_SPR_EVENT_ACK                  ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL(out_SPR_EVENT_EPCR                 ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL(out_SPR_EVENT_EEAR                 ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL(out_SPR_EVENT_EEAR_WEN             ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL(out_SPR_EVENT_SR_DSX               ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL(out_SPR_EVENT_SR_TO_ESR            ,_param->_nb_context   );
   DELETE1_SC_SIGNAL(out_CONTEXT_DECOD_ENABLE           ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_DEPTH_TAIL                     ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_DEPTH_MIN                      ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_SPR_SR_IEE                     ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_SPR_SR_EPH                     ,_param->_nb_context   );
+  DELETE1_SC_SIGNAL( in_INTERRUPT_ENABLE               ,_param->_nb_context   );
+    }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/include/Context_State.h

-              r83
+              r88
   public    : SC_CLOCK                      *  in_CLOCK        ;
   public    : SC_IN (Tcontrol_t)            *  in_NRESET       ;
+    // ~~~~~[ Interface : "branch_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_IN (Tcontrol_t         )  **  in_BRANCH_EVENT_VAL                   ;//[nb_context]
+  public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_ACK                   ;//[nb_context]
+//public    : SC_IN (Tcontext_t         )  **  in_BRANCH_EVENT_CONTEXT_ID            ;//[nb_context]
+//public    : SC_IN (Tdepth_t           )  **  in_BRANCH_EVENT_DEPTH                 ;//[nb_context]
+//public    : SC_IN (Tcontrol_t         )  **  in_BRANCH_EVENT_MISS_PREDICTION       ;//[nb_context]
+  public    : SC_IN (Taddress_t         )  **  in_BRANCH_EVENT_ADDRESS_SRC           ;//[nb_context]
+  public    : SC_IN (Taddress_t         )  **  in_BRANCH_EVENT_ADDRESS_DEST          ;//[nb_context]
     // ~~~~~[ Interface : "decod_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Interface : "commit_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t         )  **  in_COMMIT_EVENT_VAL                   ;//[nb_ooo_engine]
   public    : SC_OUT(Tcontrol_t         )  ** out_COMMIT_EVENT_ACK                   ;//[nb_ooo_engine]
   public    : SC_IN (Tcontext_t         )  **  in_COMMIT_EVENT_CONTEXT_ID            ;//[nb_ooo_engine]
   public    : SC_IN (Tdepth_t           )  **  in_COMMIT_EVENT_DEPTH                 ;//[nb_ooo_engine]
   public    : SC_IN (Tevent_type_t      )  **  in_COMMIT_EVENT_TYPE                  ;//[nb_ooo_engine]
   public    : SC_IN (Tcontrol_t         )  **  in_COMMIT_EVENT_IS_DELAY_SLOT         ;//[nb_ooo_engine]
   public    : SC_IN (Taddress_t         )  **  in_COMMIT_EVENT_ADDRESS               ;//[nb_ooo_engine]
   public    : SC_IN (Taddress_t         )  **  in_COMMIT_EVENT_ADDRESS_EPCR          ;//[nb_ooo_engine]
   public    : SC_IN (Tcontrol_t         )  **  in_COMMIT_EVENT_ADDRESS_EEAR_VAL      ;//[nb_ooo_engine]
   public    : SC_IN (Taddress_t         )  **  in_COMMIT_EVENT_ADDRESS_EEAR          ;//[nb_ooo_engine]
+  public    : SC_IN (Tcontrol_t         )   *  in_COMMIT_EVENT_VAL                   ;
+  public    : SC_OUT(Tcontrol_t         )   * out_COMMIT_EVENT_ACK                   ;
+  public    : SC_IN (Tcontext_t         )   *  in_COMMIT_EVENT_CONTEXT_ID            ;
+  public    : SC_IN (Tdepth_t           )   *  in_COMMIT_EVENT_DEPTH                 ;
+  public    : SC_IN (Tevent_type_t      )   *  in_COMMIT_EVENT_TYPE                  ;
+  public    : SC_IN (Tcontrol_t         )   *  in_COMMIT_EVENT_IS_DELAY_SLOT         ;
+  public    : SC_IN (Taddress_t         )   *  in_COMMIT_EVENT_ADDRESS               ;
+  public    : SC_IN (Taddress_t         )   *  in_COMMIT_EVENT_ADDRESS_EPCR          ;
+  public    : SC_IN (Tcontrol_t         )   *  in_COMMIT_EVENT_ADDRESS_EEAR_VAL      ;
+  public    : SC_IN (Taddress_t         )   *  in_COMMIT_EVENT_ADDRESS_EEAR          ;
     // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcounter_t         )  **  in_NB_INST_DECOD_ALL                  ;//[nb_decod_unit]
   public    : SC_IN (Tcounter_t         )  **  in_NB_INST_COMMIT_ALL                 ;//[nb_ooo_engine]
   public    : SC_IN (Tcounter_t         )  **  in_NB_INST_COMMIT_MEM                 ;//[nb_ooo_engine]
+  public    : SC_IN (Tcounter_t         )  **  in_NB_INST_DECOD_ALL                  ;//[nb_context]
+  public    : SC_IN (Tcounter_t         )  **  in_NB_INST_COMMIT_ALL                 ;//[nb_context]
+  public    : SC_IN (Tcounter_t         )  **  in_NB_INST_COMMIT_MEM                 ;//[nb_context]
     // ~~~~~[ Interface "event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_OUT(Tcontrol_t         )  ** out_EVENT_IS_DS_TAKE                   ;//[nb_context]
     // ~~~~~[ Interface "spr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t         )  ** out_SPR_VAL                            ;//[nb_context]
   public    : SC_IN (Tcontrol_t         )  **  in_SPR_ACK                            ;//[nb_context]
   public    : SC_OUT(Taddress_t         )  ** out_SPR_EPCR                           ;//[nb_context]
   public    : SC_OUT(Taddress_t         )  ** out_SPR_EEAR                           ;//[nb_context]
   public    : SC_OUT(Tcontrol_t         )  ** out_SPR_EEAR_WEN                       ;//[nb_context]
   public    : SC_OUT(Tcontrol_t         )  ** out_SPR_SR_DSX                         ;//[nb_context]
   public    : SC_OUT(Tcontrol_t         )  ** out_SPR_SR_TO_ESR                      ;//[nb_context]
+    // ~~~~~[ Interface "spr_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_OUT(Tcontrol_t         )  ** out_SPR_EVENT_VAL                      ;//[nb_context]
+  public    : SC_IN (Tcontrol_t         )  **  in_SPR_EVENT_ACK                      ;//[nb_context]
+  public    : SC_OUT(Taddress_t         )  ** out_SPR_EVENT_EPCR                     ;//[nb_context]
+  public    : SC_OUT(Taddress_t         )  ** out_SPR_EVENT_EEAR                     ;//[nb_context]
+  public    : SC_OUT(Tcontrol_t         )  ** out_SPR_EVENT_EEAR_WEN                 ;//[nb_context]
+  public    : SC_OUT(Tcontrol_t         )  ** out_SPR_EVENT_SR_DSX                   ;//[nb_context]
+  public    : SC_OUT(Tcontrol_t         )  ** out_SPR_EVENT_SR_TO_ESR                ;//[nb_context]
     // ~~~~~[ Interface : "context" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_TAIL                         ;//[nb_context]
+  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_MIN                          ;//[nb_context]
+    // ~~~~~[ Interface : "spr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_IN (Tcontrol_t         )  **  in_SPR_SR_IEE                         ;//[nb_context] - Interrupt Exception Enabled
+  public    : SC_IN (Tcontrol_t         )  **  in_SPR_SR_EPH                         ;//[nb_context] - Exception Prefix High
+    // ~~~~~[ Interface : "interrupt" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_IN (Tcontrol_t         )  **  in_INTERRUPT_ENABLE                   ;//[nb_context] - Interrupt Exception
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   private   : Tcontrol_t                    * reg_EVENT_IS_DS_TAKE                   ;//[nb_context]
   private   : Tdepth_t                      * reg_EVENT_DEPTH                        ;//[nb_context]
+  private   : Tcontrol_t                    * reg_INTERRUPT_ENABLE                   ;//[nb_context]
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  private   : Tcontrol_t                    * internal_BRANCH_EVENT_ACK              ;//[nb_context]
   private   : Tcontrol_t                    * internal_DECOD_EVENT_ACK               ;//[nb_decod_unit]
   private   : Tcontrol_t                    * internal_COMMIT_EVENT_ACK              ;//[nb_ooo_engine]
+  private   : Tcontrol_t                      internal_COMMIT_EVENT_ACK              ;
   private   : Tcontrol_t                    * internal_BRANCH_COMPLETE_ACK           ;//[nb_inst_branch_complete]
   private   : Tcontrol_t                    * internal_EVENT_VAL                     ;//[nb_context]
   private   : Tcontrol_t                    * internal_SPR_VAL                       ;//[nb_context]
+  private   : Tcontrol_t                    * internal_SPR_EVENT_VAL                 ;//[nb_context]
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/include/Parameters.h

-              r83
+              r88
   public : uint32_t   _nb_context                   ;
   public : uint32_t   _nb_decod_unit                ;
-  public : uint32_t   _nb_ooo_engine                ;
   public : uint32_t   _nb_inst_branch_complete      ;
+  public : uint32_t * _size_depth                   ; //[nb_context]
+  public : uint32_t   _size_address                 ;
+  public : uint32_t * _size_inst_decod              ; //[nb_decod_unit]
+  public : uint32_t * _size_inst_commit             ; //[nb_ooo_engine]
+  public : uint32_t * _array_size_depth             ; //[nb_context]
+//public : uint32_t * _size_depth                   ; //[nb_context]
+//public : uint32_t   _size_address                 ;
+//public : uint32_t * _size_nb_inst_decod           ; //[nb_decod_unit]
+//public : uint32_t   _size_nb_inst_commit          ;
   public : uint32_t * _link_context_to_decod_unit   ; //[nb_context]
-  public : uint32_t * _link_decod_unit_to_ooo_engine; //[nb_decod_unit]
-  public : uint32_t   _size_context_id;
-  public : uint32_t   _size_max_depth ;
-  public : bool       _have_port_context_id;
-  public : bool     * _have_port_depth     ;
-  public : bool       _have_port_max_depth ;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t   nb_context,
                         uint32_t   nb_decod_unit,
-                        uint32_t   nb_ooo_engine,
                         uint32_t   nb_inst_branch_complete,
                         uint32_t * size_depth,
                         uint32_t   size_address,
                         uint32_t * size_inst_decod,
                         uint32_t * size_inst_commit,
+                        uint32_t * size_nb_inst_decod,
+                        uint32_t   size_nb_inst_commit,
                         uint32_t * link_context_to_decod_unit,
                         uint32_t * link_decod_unit_to_ooo_engine);
+                        bool       is_toplevel=false);
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State.cpp

-              r83
+              r88
     usage_environment(_usage);
+#if DEBUG_Context_State == true
+    log_printf(INFO,Context_State,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Context_State,FUNCTION,_("Allocation"));
 …
     if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        // Constant
+        // Constant
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            internal_BRANCH_EVENT_ACK [i] = 1;
+            PORT_WRITE(out_BRANCH_EVENT_ACK [i], internal_BRANCH_EVENT_ACK [i]);
+          }
         for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+          {
 …
+          }
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+          {
+            internal_COMMIT_EVENT_ACK [i] = 1;
+            PORT_WRITE(out_COMMIT_EVENT_ACK [i], internal_COMMIT_EVENT_ACK [i]);
+          }
+        internal_COMMIT_EVENT_ACK = 1;
+        PORT_WRITE(out_COMMIT_EVENT_ACK, internal_COMMIT_EVENT_ACK);
         for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_allocation.cpp

-              r83
+              r88
+    }
+    // ~~~~~[ Interface : "branch_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("branch_event", IN,SOUTH, "branch_event", _param->_nb_context);
+      ALLOC1_VALACK_IN ( in_BRANCH_EVENT_VAL                   ,VAL);
+      ALLOC1_VALACK_OUT(out_BRANCH_EVENT_ACK                   ,ACK);
+//    ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_CONTEXT_ID            ,"context_id"             ,Tcontext_t         ,_param->_size_context_id);
+//    ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_DEPTH                 ,"depth"                  ,Tdepth_t           ,_param->_size_depth);
+//    ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_MISS_PREDICTION       ,"miss_prediction"        ,Tcontrol_t         ,1);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_ADDRESS_SRC           ,"address_src"            ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_EVENT_ADDRESS_DEST          ,"address_dest"           ,Taddress_t         ,_param->_size_instruction_address);
+    }
     // ~~~~~[ Interface : "decod_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
 …
       ALLOC1_VALACK_OUT(out_DECOD_EVENT_ACK                    ,ACK);
       ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_CONTEXT_ID             ,"context_id"             ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_DEPTH                  ,"depth"                  ,Tdepth_t           ,_param->_size_max_depth);
+      ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_DEPTH                  ,"depth"                  ,Tdepth_t           ,_param->_size_depth);
       ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_TYPE                   ,"type"                   ,Tevent_type_t      ,_param->_size_event_type);
       ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_IS_DELAY_SLOT          ,"is_delay_slot"          ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_ADDRESS                ,"address"                ,Taddress_t         ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_ADDRESS_EPCR           ,"address_epcr"           ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_ADDRESS                ,"address"                ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_EVENT_ADDRESS_EPCR           ,"address_epcr"           ,Taddress_t         ,_param->_size_instruction_address);
+    }
     // ~~~~~[ Interface : "commit_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC1_INTERFACE("commit_event",IN ,EAST, _("Interface with the Re Order Buffer"), _param->_nb_ooo_engine);
       ALLOC1_VALACK_IN ( in_COMMIT_EVENT_VAL                   ,VAL);
       ALLOC1_VALACK_OUT(out_COMMIT_EVENT_ACK                   ,ACK);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_CONTEXT_ID            ,"context_id"      ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_DEPTH                 ,"depth"           ,Tdepth_t           ,_param->_size_max_depth);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_TYPE                  ,"type"            ,Tevent_type_t      ,_param->_size_event_type);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_IS_DELAY_SLOT         ,"is_delay_slot"   ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_ADDRESS               ,"address"         ,Taddress_t         ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_ADDRESS_EPCR          ,"address_epcr"    ,Taddress_t         ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_ADDRESS_EEAR_VAL      ,"address_eear_val",Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_COMMIT_EVENT_ADDRESS_EEAR          ,"address_eear"    ,Taddress_t         ,_param->_size_address);
+      ALLOC_INTERFACE("commit_event",IN ,EAST, _("Interface with the Re Order Buffer"));
+      ALLOC_VALACK_IN  ( in_COMMIT_EVENT_VAL                   ,VAL);
+      ALLOC_VALACK_OUT (out_COMMIT_EVENT_ACK                   ,ACK);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_CONTEXT_ID            ,"context_id"      ,Tcontext_t         ,_param->_size_context_id);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_DEPTH                 ,"depth"           ,Tdepth_t           ,_param->_size_depth);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_TYPE                  ,"type"            ,Tevent_type_t      ,_param->_size_event_type);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_IS_DELAY_SLOT         ,"is_delay_slot"   ,Tcontrol_t         ,1);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_ADDRESS               ,"address"         ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_ADDRESS_EPCR          ,"address_epcr"    ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_ADDRESS_EEAR_VAL      ,"address_eear_val",Tcontrol_t         ,1);
+      ALLOC_SIGNAL_IN  ( in_COMMIT_EVENT_ADDRESS_EEAR          ,"address_eear"    ,Taddress_t         ,_param->_size_instruction_address);
+    }
 …
       ALLOC1_VALACK_OUT(out_BRANCH_COMPLETE_ACK                ,ACK);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_CONTEXT_ID         ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH              ,"depth"          ,Tdepth_t           ,_param->_size_max_depth);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH              ,"depth"          ,Tdepth_t           ,_param->_size_depth);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_MISS_PREDICTION    ,"miss_prediction",Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_TAKE               ,"take"           ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS_SRC        ,"address_src"    ,Taddress_t         ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS_DEST       ,"address_dest"   ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS_SRC        ,"address_src"    ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS_DEST       ,"address_dest"   ,Taddress_t         ,_param->_size_instruction_address);
+    }
     // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("nb_inst",IN ,EAST, _("Interface to count in fligt present instruction."), _param->_nb_decod_unit);
+      ALLOC1_SIGNAL_IN ( in_NB_INST_DECOD_ALL                  ,"decod_all" ,Tcounter_t         ,_param->_size_inst_decod  [alloc_signal_it1]);
+//    ALLOC1_SIGNAL_IN ( in_NB_INST_COMMIT_ALL                 ,"commit_all",Tcounter_t         ,_param->_size_inst_commit [alloc_signal_it1]);
+//    ALLOC1_SIGNAL_IN ( in_NB_INST_COMMIT_MEM                 ,"commit_mem",Tcounter_t         ,_param->_size_inst_commit [alloc_signal_it1]);
+    }
+    {
+      ALLOC1_INTERFACE("nb_inst",IN ,EAST, _("Interface to count in fligt present instruction."), _param->_nb_ooo_engine);
+//    ALLOC1_SIGNAL_IN ( in_NB_INST_DECOD_ALL                  ,"decod_all" ,Tcounter_t         ,_param->_size_inst_decod  [alloc_signal_it1]);
+      ALLOC1_SIGNAL_IN ( in_NB_INST_COMMIT_ALL                 ,"commit_all",Tcounter_t         ,_param->_size_inst_commit [alloc_signal_it1]);
+      ALLOC1_SIGNAL_IN ( in_NB_INST_COMMIT_MEM                 ,"commit_mem",Tcounter_t         ,_param->_size_inst_commit [alloc_signal_it1]);
+      ALLOC1_INTERFACE("nb_inst",IN ,EAST, _("Interface to count in fligt present instruction."),_param->_nb_context);
+      ALLOC1_SIGNAL_IN ( in_NB_INST_DECOD_ALL                  ,"decod_all" ,Tcounter_t         ,_param->_size_nb_inst_decod);
+      ALLOC1_SIGNAL_IN ( in_NB_INST_COMMIT_ALL                 ,"commit_all",Tcounter_t         ,_param->_size_nb_inst_commit);
+      ALLOC1_SIGNAL_IN ( in_NB_INST_COMMIT_MEM                 ,"commit_mem",Tcounter_t         ,_param->_size_nb_inst_commit);
+    }
 …
       ALLOC1_VALACK_OUT(out_EVENT_VAL                          ,VAL);
       ALLOC1_VALACK_IN ( in_EVENT_ACK                          ,ACK);
       ALLOC1_SIGNAL_OUT(out_EVENT_ADDRESS                      ,"address"         ,Taddress_t        ,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_EVENT_ADDRESS_NEXT                 ,"address_next"    ,Taddress_t        ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_EVENT_ADDRESS                      ,"address"         ,Taddress_t        ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_EVENT_ADDRESS_NEXT                 ,"address_next"    ,Taddress_t        ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_EVENT_ADDRESS_NEXT_VAL             ,"address_next_val",Tcontrol_t        ,1);
       ALLOC1_SIGNAL_OUT(out_EVENT_IS_DS_TAKE                   ,"is_ds_take"      ,Tcontrol_t        ,1);
+    }
     // ~~~~~[ Interface "spr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC1_INTERFACE("spr",OUT,WEST, _("An exception occure : write \"exception PC\"."), _param->_nb_context);
       ALLOC1_VALACK_OUT(out_SPR_VAL                            ,VAL);
       ALLOC1_VALACK_IN ( in_SPR_ACK                            ,ACK);
       ALLOC1_SIGNAL_OUT(out_SPR_EPCR                           ,"epcr"     ,Taddress_t, _param->_size_address);
       ALLOC1_SIGNAL_OUT(out_SPR_EEAR                           ,"eear"     ,Taddress_t, _param->_size_address);
       ALLOC1_SIGNAL_OUT(out_SPR_EEAR_WEN                       ,"eear_wen" ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_SPR_SR_DSX                         ,"sr_dsx"   ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_SPR_SR_TO_ESR                      ,"sr_to_esr",Tcontrol_t,1);
+    // ~~~~~[ Interface "spr_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("spr_event",OUT,WEST, _("An exception occure : write \"exception PC\"."), _param->_nb_context);
+      ALLOC1_VALACK_OUT(out_SPR_EVENT_VAL                      ,VAL);
+      ALLOC1_VALACK_IN ( in_SPR_EVENT_ACK                      ,ACK);
+      ALLOC1_SIGNAL_OUT(out_SPR_EVENT_EPCR                     ,"epcr"     ,Taddress_t, _param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_SPR_EVENT_EEAR                     ,"eear"     ,Taddress_t, _param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_SPR_EVENT_EEAR_WEN                 ,"eear_wen" ,Tcontrol_t,1);
+      ALLOC1_SIGNAL_OUT(out_SPR_EVENT_SR_DSX                   ,"sr_dsx"   ,Tcontrol_t,1);
+      ALLOC1_SIGNAL_OUT(out_SPR_EVENT_SR_TO_ESR                ,"sr_to_esr",Tcontrol_t,1);
+    }
 …
       ALLOC1_INTERFACE("depth",IN ,NORTH, _("From prediction_unit."), _param->_nb_context);
+      ALLOC1_SIGNAL_IN ( in_DEPTH_TAIL                         ,"tail",Tdepth_t,_param->_size_depth [alloc_signal_it1]);
+    }
+    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    reg_STATE                  = new context_state_t [_param->_nb_context];
+    reg_EVENT_ADDRESS          = new Taddress_t      [_param->_nb_context];
+    reg_EVENT_ADDRESS_EPCR     = new Taddress_t      [_param->_nb_context];
+    reg_EVENT_ADDRESS_EPCR_VAL = new Tcontrol_t      [_param->_nb_context];
+    reg_EVENT_ADDRESS_EEAR     = new Taddress_t      [_param->_nb_context];
+    reg_EVENT_ADDRESS_EEAR_VAL = new Tcontrol_t      [_param->_nb_context];
+    reg_EVENT_IS_DELAY_SLOT    = new Tcontrol_t      [_param->_nb_context];
+    reg_EVENT_IS_DS_TAKE       = new Tcontrol_t      [_param->_nb_context];
+    reg_EVENT_DEPTH            = new Tdepth_t        [_param->_nb_context];
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    internal_DECOD_EVENT_ACK     = new Tcontrol_t [_param->_nb_decod_unit];
+    internal_COMMIT_EVENT_ACK    = new Tcontrol_t [_param->_nb_ooo_engine];
+    internal_BRANCH_COMPLETE_ACK = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_EVENT_VAL           = new Tcontrol_t [_param->_nb_context];
+    internal_SPR_VAL             = new Tcontrol_t [_param->_nb_context];
+      ALLOC1_SIGNAL_IN ( in_DEPTH_MIN                          ,"min" ,Tdepth_t,_param->_size_depth);
+    }
+    // ~~~~~[ Interface : "spr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("spr",IN,EAST,_("Interface with the special registerFile"),_param->_nb_context);
+      ALLOC1_SIGNAL_IN ( in_SPR_SR_IEE                         ,"SR_IEE",Tcontrol_t,1);
+      ALLOC1_SIGNAL_IN ( in_SPR_SR_EPH                         ,"SR_EPH",Tcontrol_t,1);
+    }
+    // ~~~~~[ Interface : "interrupt" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC1_INTERFACE("interrupt",IN,NORTH,_("Interrupt Exception"),_param->_nb_context);
+      ALLOC1_SIGNAL_IN ( in_INTERRUPT_ENABLE                   ,"ENABLE",Tcontrol_t,1);
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     reg_STATE                  = new context_state_t [_param->_nb_context];
+     reg_EVENT_ADDRESS          = new Taddress_t      [_param->_nb_context];
+     reg_EVENT_ADDRESS_EPCR     = new Taddress_t      [_param->_nb_context];
+     reg_EVENT_ADDRESS_EPCR_VAL = new Tcontrol_t      [_param->_nb_context];
+     reg_EVENT_ADDRESS_EEAR     = new Taddress_t      [_param->_nb_context];
+     reg_EVENT_ADDRESS_EEAR_VAL = new Tcontrol_t      [_param->_nb_context];
+     reg_EVENT_IS_DELAY_SLOT    = new Tcontrol_t      [_param->_nb_context];
+     reg_EVENT_IS_DS_TAKE       = new Tcontrol_t      [_param->_nb_context];
+     reg_EVENT_DEPTH            = new Tdepth_t        [_param->_nb_context];
+     reg_INTERRUPT_ENABLE       = new Tcontrol_t      [_param->_nb_context];
+     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     internal_BRANCH_EVENT_ACK    = new Tcontrol_t [_param->_nb_context];
+     internal_DECOD_EVENT_ACK     = new Tcontrol_t [_param->_nb_decod_unit];
+     internal_BRANCH_COMPLETE_ACK = new Tcontrol_t [_param->_nb_inst_branch_complete];
+     internal_EVENT_VAL           = new Tcontrol_t [_param->_nb_context];
+     internal_SPR_EVENT_VAL       = new Tcontrol_t [_param->_nb_context];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_deallocation.cpp

-              r83
+              r88
         delete    in_NRESET;
+        DELETE1_SIGNAL( in_BRANCH_EVENT_VAL                   ,_param->_nb_context,1);
+        DELETE1_SIGNAL(out_BRANCH_EVENT_ACK                   ,_param->_nb_context,1);
+//      DELETE1_SIGNAL( in_BRANCH_EVENT_CONTEXT_ID            ,_param->_nb_context,_param->_size_context_id);
+//      DELETE1_SIGNAL( in_BRANCH_EVENT_DEPTH                 ,_param->_nb_context,_param->_size_depth);
+//      DELETE1_SIGNAL( in_BRANCH_EVENT_MISS_PREDICTION       ,_param->_nb_context,1);
+        DELETE1_SIGNAL( in_BRANCH_EVENT_ADDRESS_SRC           ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_BRANCH_EVENT_ADDRESS_DEST          ,_param->_nb_context,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_DECOD_EVENT_VAL                    ,_param->_nb_decod_unit,1);
         DELETE1_SIGNAL(out_DECOD_EVENT_ACK                    ,_param->_nb_decod_unit,1);
         DELETE1_SIGNAL( in_DECOD_EVENT_CONTEXT_ID             ,_param->_nb_decod_unit,_param->_size_context_id);
         DELETE1_SIGNAL( in_DECOD_EVENT_DEPTH                  ,_param->_nb_decod_unit,_param->_size_max_depth);
+        DELETE1_SIGNAL( in_DECOD_EVENT_DEPTH                  ,_param->_nb_decod_unit,_param->_size_depth);
         DELETE1_SIGNAL( in_DECOD_EVENT_TYPE                   ,_param->_nb_decod_unit,_param->_size_event_type);
         DELETE1_SIGNAL( in_DECOD_EVENT_IS_DELAY_SLOT          ,_param->_nb_decod_unit,1);
         DELETE1_SIGNAL( in_DECOD_EVENT_ADDRESS                ,_param->_nb_decod_unit,_param->_size_address);
         DELETE1_SIGNAL( in_DECOD_EVENT_ADDRESS_EPCR           ,_param->_nb_decod_unit,_param->_size_address);
+        DELETE1_SIGNAL( in_DECOD_EVENT_ADDRESS                ,_param->_nb_decod_unit,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_DECOD_EVENT_ADDRESS_EPCR           ,_param->_nb_decod_unit,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_COMMIT_EVENT_VAL                   ,_param->_nb_ooo_engine,1);
         DELETE1_SIGNAL(out_COMMIT_EVENT_ACK                   ,_param->_nb_ooo_engine,1);
         DELETE1_SIGNAL( in_COMMIT_EVENT_CONTEXT_ID            ,_param->_nb_ooo_engine,_param->_size_context_id);
         DELETE1_SIGNAL( in_COMMIT_EVENT_DEPTH                 ,_param->_nb_ooo_engine,_param->_size_max_depth);
         DELETE1_SIGNAL( in_COMMIT_EVENT_TYPE                  ,_param->_nb_ooo_engine,_param->_size_event_type);
         DELETE1_SIGNAL( in_COMMIT_EVENT_IS_DELAY_SLOT         ,_param->_nb_ooo_engine,1);
         DELETE1_SIGNAL( in_COMMIT_EVENT_ADDRESS               ,_param->_nb_ooo_engine,_param->_size_address);
         DELETE1_SIGNAL( in_COMMIT_EVENT_ADDRESS_EPCR          ,_param->_nb_ooo_engine,_param->_size_address);
         DELETE1_SIGNAL( in_COMMIT_EVENT_ADDRESS_EEAR_VAL      ,_param->_nb_ooo_engine,_param->_size_address);
         DELETE1_SIGNAL( in_COMMIT_EVENT_ADDRESS_EEAR          ,_param->_nb_ooo_engine,1);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_VAL                   ,1);
+        DELETE_SIGNAL (out_COMMIT_EVENT_ACK                   ,1);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_CONTEXT_ID            ,_param->_size_context_id);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_DEPTH                 ,_param->_size_depth);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_TYPE                  ,_param->_size_event_type);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_IS_DELAY_SLOT         ,1);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_ADDRESS               ,_param->_size_instruction_address);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EPCR          ,_param->_size_instruction_address);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EEAR_VAL      ,_param->_size_instruction_address);
+        DELETE_SIGNAL ( in_COMMIT_EVENT_ADDRESS_EEAR          ,1);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_VAL                ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL(out_BRANCH_COMPLETE_ACK                ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_CONTEXT_ID         ,_param->_nb_inst_branch_complete,_param->_size_context_id);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_DEPTH              ,_param->_nb_inst_branch_complete,_param->_size_max_depth);
+        DELETE1_SIGNAL( in_BRANCH_COMPLETE_DEPTH              ,_param->_nb_inst_branch_complete,_param->_size_depth);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_MISS_PREDICTION    ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_TAKE               ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_ADDRESS_SRC        ,_param->_nb_inst_branch_complete,_param->_size_address);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_ADDRESS_DEST       ,_param->_nb_inst_branch_complete,_param->_size_address);
+        DELETE1_SIGNAL( in_BRANCH_COMPLETE_ADDRESS_SRC        ,_param->_nb_inst_branch_complete,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_BRANCH_COMPLETE_ADDRESS_DEST       ,_param->_nb_inst_branch_complete,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_NB_INST_DECOD_ALL                  ,_param->_nb_decod_unit,_param->_size_inst_decod  [alloc_signal_it1]);
+//      DELETE1_SIGNAL( in_NB_INST_COMMIT_ALL                 ,_param->_nb_decod_unit,_param->_size_inst_commit [alloc_signal_it1]);
+//      DELETE1_SIGNAL( in_NB_INST_COMMIT_MEM                 ,_param->_nb_decod_unit,_param->_size_inst_commit [alloc_signal_it1]);
+//      DELETE1_SIGNAL( in_NB_INST_DECOD_ALL                  ,_param->_nb_ooo_engine,_param->_size_inst_decod  [alloc_signal_it1]);
+        DELETE1_SIGNAL( in_NB_INST_COMMIT_ALL                 ,_param->_nb_ooo_engine,_param->_size_inst_commit [alloc_signal_it1]);
+        DELETE1_SIGNAL( in_NB_INST_COMMIT_MEM                 ,_param->_nb_ooo_engine,_param->_size_inst_commit [alloc_signal_it1]);
+        DELETE1_SIGNAL( in_NB_INST_DECOD_ALL                  ,_param->_nb_context,_param->_size_nb_inst_decod);
+        DELETE1_SIGNAL( in_NB_INST_COMMIT_ALL                 ,_param->_nb_context,_param->_size_nb_inst_commit);
+        DELETE1_SIGNAL( in_NB_INST_COMMIT_MEM                 ,_param->_nb_context,_param->_size_nb_inst_commit);
         DELETE1_SIGNAL(out_EVENT_VAL                          ,_param->_nb_context,1);
         DELETE1_SIGNAL( in_EVENT_ACK                          ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_EVENT_ADDRESS                      ,_param->_nb_context,_param->_size_address);
         DELETE1_SIGNAL(out_EVENT_ADDRESS_NEXT                 ,_param->_nb_context,_param->_size_address);
+        DELETE1_SIGNAL(out_EVENT_ADDRESS                      ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_EVENT_ADDRESS_NEXT                 ,_param->_nb_context,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_EVENT_ADDRESS_NEXT_VAL             ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_EVENT_IS_DS_TAKE                   ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_SPR_VAL                            ,_param->_nb_context,1);
         DELETE1_SIGNAL( in_SPR_ACK                            ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_SPR_EPCR                           ,_param->_nb_context,_param->_size_address);
         DELETE1_SIGNAL(out_SPR_EEAR                           ,_param->_nb_context,_param->_size_address);
         DELETE1_SIGNAL(out_SPR_EEAR_WEN                       ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_SPR_SR_DSX                         ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_SPR_SR_TO_ESR                      ,_param->_nb_context,1);
+        DELETE1_SIGNAL(out_SPR_EVENT_VAL                      ,_param->_nb_context,1);
+        DELETE1_SIGNAL( in_SPR_EVENT_ACK                      ,_param->_nb_context,1);
+        DELETE1_SIGNAL(out_SPR_EVENT_EPCR                     ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_SPR_EVENT_EEAR                     ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_SPR_EVENT_EEAR_WEN                 ,_param->_nb_context,1);
+        DELETE1_SIGNAL(out_SPR_EVENT_SR_DSX                   ,_param->_nb_context,1);
+        DELETE1_SIGNAL(out_SPR_EVENT_SR_TO_ESR                ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_CONTEXT_DECOD_ENABLE               ,_param->_nb_context,1);
+        DELETE1_SIGNAL( in_DEPTH_TAIL                         ,_param->_nb_context,_param->_size_depth [alloc_signal_it1]);
+        DELETE1_SIGNAL( in_DEPTH_MIN                          ,_param->_nb_context,_param->_size_depth);
+        DELETE1_SIGNAL( in_SPR_SR_IEE                         ,_param->_nb_context,1);
+        DELETE1_SIGNAL( in_SPR_SR_EPH                         ,_param->_nb_context,1);
+        DELETE1_SIGNAL( in_INTERRUPT_ENABLE                   ,_param->_nb_context,1);
+        // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] reg_STATE                 ;
+        delete [] reg_EVENT_ADDRESS         ;
+        delete [] reg_EVENT_ADDRESS_EPCR    ;
+        delete [] reg_EVENT_ADDRESS_EPCR_VAL;
+        delete [] reg_EVENT_ADDRESS_EEAR    ;
+        delete [] reg_EVENT_ADDRESS_EEAR_VAL;
+        delete [] reg_EVENT_IS_DELAY_SLOT   ;
+        delete [] reg_EVENT_IS_DS_TAKE      ;
+        delete [] reg_EVENT_DEPTH           ;
+        delete [] reg_INTERRUPT_ENABLE      ;
+        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] internal_BRANCH_EVENT_ACK ;
+        delete [] internal_DECOD_EVENT_ACK  ;
+        delete [] internal_EVENT_VAL        ;
+        delete [] internal_SPR_EVENT_VAL    ;
+      }
+    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete [] reg_STATE                 ;
+    delete [] reg_EVENT_ADDRESS         ;
+    delete [] reg_EVENT_ADDRESS_EPCR    ;
+    delete [] reg_EVENT_ADDRESS_EPCR_VAL;
+    delete [] reg_EVENT_ADDRESS_EEAR    ;
+    delete [] reg_EVENT_ADDRESS_EEAR_VAL;
+    delete [] reg_EVENT_IS_DELAY_SLOT   ;
+    delete [] reg_EVENT_IS_DS_TAKE      ;
+    delete [] reg_EVENT_DEPTH           ;
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete [] internal_DECOD_EVENT_ACK  ;
+    delete [] internal_COMMIT_EVENT_ACK ;
+    delete [] internal_EVENT_VAL        ;
+    delete [] internal_SPR_VAL          ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_genMoore.cpp

-              r83
+              r88
+  {
     log_begin(Context_State,FUNCTION);
+    log_function(Context_State,FUNCTION,_name.c_str());
     // -------------------------------------------------------------------
 …
         context_state_t state = reg_STATE [i];
+        internal_EVENT_VAL [i] = ((state == CONTEXT_STATE_KO_EXCEP_ADDR) or
+                                  (state == CONTEXT_STATE_KO_MISS_ADDR ) or
+                                  (state == CONTEXT_STATE_KO_PSYNC_ADDR) or
+                                  (state == CONTEXT_STATE_KO_CSYNC_ADDR));
+        Tcontrol_t val              = ((state == CONTEXT_STATE_KO_EXCEP_ADDR) or
+                                       (state == CONTEXT_STATE_KO_MISS_ADDR ) or
+                                       (state == CONTEXT_STATE_KO_PSYNC_ADDR) or
+                                       (state == CONTEXT_STATE_KO_CSYNC_ADDR));
+        // SR can't change in this cycle
+        // Exception Prefix High
+        Taddress_t address          = reg_EVENT_ADDRESS [i] | (((state == CONTEXT_STATE_KO_EXCEP_ADDR) and PORT_READ(in_SPR_SR_EPH [i]))?(0xF000000>>2):0);
+        Taddress_t address_next     = reg_EVENT_ADDRESS_EPCR [i];
+        Tcontrol_t address_next_val = (state == CONTEXT_STATE_KO_MISS_ADDR) and (reg_EVENT_ADDRESS_EPCR_VAL [i]);
+        Tcontrol_t is_ds_take       = (state == CONTEXT_STATE_KO_MISS_ADDR) and (reg_EVENT_IS_DS_TAKE       [i]);
         // excep : address exception
         // miss  : address delay_slot, and address dest
         // psync : address next
         // csync : address next
+        PORT_WRITE(out_EVENT_VAL              [i], internal_EVENT_VAL     [i]);
+        PORT_WRITE(out_EVENT_ADDRESS          [i], reg_EVENT_ADDRESS      [i]);
+        PORT_WRITE(out_EVENT_ADDRESS_NEXT     [i], reg_EVENT_ADDRESS_EPCR [i]);
+        PORT_WRITE(out_EVENT_ADDRESS_NEXT_VAL [i], (state == CONTEXT_STATE_KO_MISS_ADDR) and (reg_EVENT_ADDRESS_EPCR_VAL [i]));
+        PORT_WRITE(out_EVENT_IS_DS_TAKE       [i], (state == CONTEXT_STATE_KO_MISS_ADDR) and (reg_EVENT_IS_DS_TAKE       [i]));
+        internal_EVENT_VAL [i] = val;
+        PORT_WRITE(out_EVENT_VAL              [i], val);
+        PORT_WRITE(out_EVENT_ADDRESS          [i], address);
+        PORT_WRITE(out_EVENT_ADDRESS_NEXT     [i], address_next);
+        PORT_WRITE(out_EVENT_ADDRESS_NEXT_VAL [i], address_next_val);
+        PORT_WRITE(out_EVENT_IS_DS_TAKE       [i], is_ds_take);
+        log_printf(TRACE,Context_State,FUNCTION,"  * EVENT Context      : %d", i);
+        log_printf(TRACE,Context_State,FUNCTION,"    * VAL              : %d", val);
+        log_printf(TRACE,Context_State,FUNCTION,"    * ADDRESS          : %.8x (%.8x)", address     , address     <<2);
+        log_printf(TRACE,Context_State,FUNCTION,"    * ADDRESS_NEXT     : %.8x (%.8x)", address_next, address_next<<2);
+        log_printf(TRACE,Context_State,FUNCTION,"    * ADDRESS_NEXT_VAL : %d", address_next_val);
+        log_printf(TRACE,Context_State,FUNCTION,"    * IS_DS_TAKE       : %d", is_ds_take);
+      }
     // -------------------------------------------------------------------
     // -----[ SPR ]-------------------------------------------------------
+    // -----[ SPR_EVENT ]-------------------------------------------------
     // -------------------------------------------------------------------
     for (uint32_t i=0; i<_param->_nb_context; i++)
 …
         context_state_t state = reg_STATE [i];
         internal_SPR_VAL [i] = (state == CONTEXT_STATE_KO_EXCEP_SPR  );
+        internal_SPR_EVENT_VAL [i] = (state == CONTEXT_STATE_KO_EXCEP_SPR  );
         PORT_WRITE(out_SPR_VAL       [i], internal_SPR_VAL           [i]);
         PORT_WRITE(out_SPR_EPCR      [i], reg_EVENT_ADDRESS_EPCR     [i]);
         PORT_WRITE(out_SPR_EEAR      [i], reg_EVENT_ADDRESS_EEAR     [i]);
         PORT_WRITE(out_SPR_EEAR_WEN  [i], reg_EVENT_ADDRESS_EEAR_VAL [i]);
         PORT_WRITE(out_SPR_SR_DSX    [i], reg_EVENT_IS_DELAY_SLOT    [i]);
         PORT_WRITE(out_SPR_SR_TO_ESR [i], 1);
+        PORT_WRITE(out_SPR_EVENT_VAL       [i], internal_SPR_EVENT_VAL     [i]);
+        PORT_WRITE(out_SPR_EVENT_EPCR      [i], reg_EVENT_ADDRESS_EPCR     [i]);
+        PORT_WRITE(out_SPR_EVENT_EEAR      [i], reg_EVENT_ADDRESS_EEAR     [i]);
+        PORT_WRITE(out_SPR_EVENT_EEAR_WEN  [i], reg_EVENT_ADDRESS_EEAR_VAL [i]);
+        PORT_WRITE(out_SPR_EVENT_SR_DSX    [i], reg_EVENT_IS_DELAY_SLOT    [i]);
+        PORT_WRITE(out_SPR_EVENT_SR_TO_ESR [i], 1);
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Context_State_transition.cpp

-              r83
+              r88
+  {
     log_begin(Context_State,FUNCTION);
+    log_function(Context_State,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
+      {
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          reg_STATE [i] = CONTEXT_STATE_OK;
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            reg_STATE            [i] = CONTEXT_STATE_OK;
+            reg_INTERRUPT_ENABLE [i] = 0;
+          }
+      }
     else
+      {
+        // -------------------------------------------------------------------
+        // -----[ DECOD_EVENT ]-----------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+          if (PORT_READ(in_DECOD_EVENT_VAL [i]) and internal_DECOD_EVENT_ACK [i])
+            {
+              Tcontext_t context    = (_param->_have_port_context_id     )?PORT_READ(in_DECOD_EVENT_CONTEXT_ID [i]):0;
+              Tdepth_t   depth      = (_param->_have_port_max_depth      )?PORT_READ(in_DECOD_EVENT_DEPTH      [i]):0;
+              Tdepth_t   depth_cur  = reg_EVENT_DEPTH [context];
+              Tdepth_t   depth_base = (_param->_have_port_depth [context])?PORT_READ(in_DEPTH_TAIL       [context]):0;
+              Tdepth_t   depth_max  = _param->_size_depth [context];
+              Tdepth_t   depth0     = (depth_cur>=depth_base)?(depth_cur-depth_base):((depth_cur+depth_max-depth_base));
+              Tdepth_t   depth1     = (depth    >=depth_base)?(depth    -depth_base):((depth    +depth_max-depth_base));
+              context_state_t state = reg_STATE [context];
+              Tevent_type_t   type  = PORT_READ(in_DECOD_EVENT_TYPE [i]);
+              // miss > excep > spr/sync
+              uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == CONTEXT_STATE_KO_EXCEP)?1:0);
+              uint8_t    priority1  = (state == EVENT_TYPE_EXCEPTION)?1:0;
+              // is_valid = can modify local information
+              //  if context_state_ok : yes
+              //  if context_state_ko : test the depth, and the priority of envent
+              bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                       (depth1< depth0) or
+                                       ((depth1==depth0) and (priority1>priority0)));
+              if (is_valid)
+                {
+                  // decod :
+                  // type : csync, psync, msync, spr_access (l.mac, l.maci, l.macrc, l.msb, l.mfspr, l.mtspr), exception (l.sys)
+                  context_state_t state_next    = state;
+                  Taddress_t      address       = PORT_READ(in_DECOD_EVENT_ADDRESS       [i]);
+                  Tcontrol_t      is_delay_slot = PORT_READ(in_DECOD_EVENT_IS_DELAY_SLOT [i]);
+                  switch (type)
+                    {
+                    case EVENT_TYPE_EXCEPTION          :
+                      {
+                        state_next = CONTEXT_STATE_KO_EXCEP;
+                        break;
+                      }
+                    case EVENT_TYPE_SPR_ACCESS         :
+                      {
+                        state_next = CONTEXT_STATE_KO_SPR  ;
+                        address++; // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_MSYNC              :
+                      {
+                        state_next = CONTEXT_STATE_KO_MSYNC;
+                        address++;  // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_PSYNC              :
+                      {
+                        state_next = CONTEXT_STATE_KO_PSYNC;
+                        address++;  // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_CSYNC              :
+                      {
+                        state_next = CONTEXT_STATE_KO_CSYNC;
+                        address++;  // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_NONE               :
+                    case EVENT_TYPE_MISS_SPECULATION   :
+                    case EVENT_TYPE_BRANCH_NO_ACCURATE :
+                    default :
+                      {
+                        throw ERRORMORPHEO(FUNCTION,toString(_("DECOD_EVENT [%d] : invalid event_type : %s.\n"),i,toString(type).c_str()));
+                      }
+                    }
+                  reg_STATE                  [context] = state_next;
+                  reg_EVENT_ADDRESS          [context] = address;
+                  reg_EVENT_ADDRESS_EPCR     [context] = PORT_READ(in_DECOD_EVENT_ADDRESS_EPCR  [i]);
+                  reg_EVENT_ADDRESS_EPCR_VAL [context] = 1;
+                //reg_EVENT_ADDRESS_EEAR     [context]
+                  reg_EVENT_ADDRESS_EEAR_VAL [context] = 0;
+                  reg_EVENT_IS_DELAY_SLOT    [context] = is_delay_slot;
+                //reg_EVENT_IS_DS_TAKE       [context] = 0;
+                  reg_EVENT_DEPTH            [context] = depth;
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ COMMIT_EVENT ]----------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
+          if (PORT_READ(in_COMMIT_EVENT_VAL [i]) and internal_COMMIT_EVENT_ACK [i])
+            {
+              Tcontext_t context    = (_param->_have_port_context_id     )?PORT_READ(in_COMMIT_EVENT_CONTEXT_ID [i]):0;
+              Tdepth_t   depth      = (_param->_have_port_max_depth      )?PORT_READ(in_COMMIT_EVENT_DEPTH      [i]):0;
+              Tdepth_t   depth_cur  = reg_EVENT_DEPTH [context];
+              Tdepth_t   depth_base = (_param->_have_port_depth [context])?PORT_READ(in_DEPTH_TAIL        [context]):0;
+              Tdepth_t   depth_max  = _param->_size_depth [context];
+              Tdepth_t   depth0     = (depth_cur>=depth_base)?(depth_cur-depth_base):((depth_cur+depth_max-depth_base));
+              Tdepth_t   depth1     = (depth    >=depth_base)?(depth    -depth_base):((depth    +depth_max-depth_base));
+              context_state_t state = reg_STATE [context];
+              Tevent_type_t   type  = PORT_READ(in_COMMIT_EVENT_TYPE [i]);
+              // miss > excep > spr/sync
+              uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == CONTEXT_STATE_KO_EXCEP)?1:0);
+              uint8_t    priority1  = 1;
+              // is_valid = can modify local information
+              //  if context_state_ok : yes
+              //  if context_state_ko : test the depth, and the priority of envent
+              bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                       (depth1< depth0) or
+                                       ((depth1==depth0) and (priority1>priority0)));
+              if (is_valid)
+                {
+                  // commit
+                  // type : exception
+                  context_state_t state_next = state;
+                  switch (type)
+                    {
+                    case EVENT_TYPE_EXCEPTION          : {state_next = CONTEXT_STATE_KO_EXCEP; break;}
+                    case EVENT_TYPE_SPR_ACCESS         :
+                    case EVENT_TYPE_MSYNC              :
+                    case EVENT_TYPE_PSYNC              :
+                    case EVENT_TYPE_CSYNC              :
+                    case EVENT_TYPE_NONE               :
+                    case EVENT_TYPE_MISS_SPECULATION   :
+                    case EVENT_TYPE_BRANCH_NO_ACCURATE :
+                    default :
+                      {
+                        throw ERRORMORPHEO(FUNCTION,toString(_("COMMIT_EVENT [%d] : invalid event_type : %s.\n"),i,toString(type).c_str()));
+                      }
+                    }
+                  reg_STATE                  [context] = state_next;
+                  reg_EVENT_ADDRESS          [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS          [i]);
+                  reg_EVENT_ADDRESS_EPCR     [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS_EPCR     [i]);
+                  reg_EVENT_ADDRESS_EPCR_VAL [context] = 1;
+                  reg_EVENT_ADDRESS_EEAR     [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS_EEAR     [i]);
+                  reg_EVENT_ADDRESS_EEAR_VAL [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS_EEAR_VAL [i]);
+                  reg_EVENT_IS_DELAY_SLOT    [context] = PORT_READ(in_COMMIT_EVENT_IS_DELAY_SLOT    [i]);
+                //reg_EVENT_IS_DS_TAKE       [context] = 0;
+                  reg_EVENT_DEPTH            [context] = depth;
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ BRANCH_COMPLETE ]-------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          if (PORT_READ(in_BRANCH_COMPLETE_VAL [i]) and internal_BRANCH_COMPLETE_ACK [i])
+            {
+              if (PORT_READ(in_BRANCH_COMPLETE_MISS_PREDICTION [i]))
+                {
+                  Tcontext_t context    = (_param->_have_port_context_id     )?PORT_READ(in_BRANCH_COMPLETE_CONTEXT_ID [i]):0;
+                  Tdepth_t   depth      = (_param->_have_port_max_depth      )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
+                  Tdepth_t   depth_cur  = reg_EVENT_DEPTH [context];
+                  Tdepth_t   depth_base = (_param->_have_port_depth [context])?PORT_READ(in_DEPTH_TAIL        [context]):0;
+                  Tdepth_t   depth_max  = _param->_size_depth [context];
+                  Tdepth_t   depth0     = (depth_cur>=depth_base)?(depth_cur-depth_base):((depth_cur+depth_max-depth_base));
+                  Tdepth_t   depth1     = (depth    >=depth_base)?(depth    -depth_base):((depth    +depth_max-depth_base));
+                  context_state_t state = reg_STATE [context];
+                  // miss > excep > spr/sync
+                  uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == CONTEXT_STATE_KO_EXCEP)?1:0);
+                  uint8_t    priority1  = 2;
+                  // is_valid = can modify local information
+                  //  if context_state_ok : yes
+                  //  if context_state_ko : test the depth, and the priority of envent
+                  bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                           (depth1< depth0) or
+                                           ((depth1==depth0) and (priority1>priority0)));
+                  if (is_valid)
+                    {
+                      // commit
+                      Tcontrol_t take = PORT_READ(in_BRANCH_COMPLETE_TAKE [i]);
+                      reg_STATE                  [context] = CONTEXT_STATE_KO_MISS;
+                      reg_EVENT_ADDRESS          [context] = PORT_READ(in_BRANCH_COMPLETE_ADDRESS_SRC  [i])+1; //DELAY_SLOT
+                      reg_EVENT_ADDRESS_EPCR     [context] = PORT_READ(in_BRANCH_COMPLETE_ADDRESS_DEST [i]);
+                      reg_EVENT_ADDRESS_EPCR_VAL [context] = take; // if not take : in sequence
+                    //reg_EVENT_ADDRESS_EEAR     [context];
+                    //reg_EVENT_ADDRESS_EEAR_VAL [context];
+                      reg_EVENT_IS_DELAY_SLOT    [context] = take;
+                      reg_EVENT_IS_DS_TAKE       [context] = take;
+                      reg_EVENT_DEPTH            [context] = depth;
+                    }
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ EVENT ]-----------------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          if (internal_EVENT_VAL [i] and PORT_READ(in_EVENT_ACK [i]))
+            {
+              // Write pc
+              context_state_t state = reg_STATE [i];
+              switch (state)
+                {
+                case CONTEXT_STATE_KO_EXCEP_ADDR :
+                  {
+                    reg_STATE [i] = CONTEXT_STATE_KO_EXCEP_SPR;
+                    break;
+                  }
+                case CONTEXT_STATE_KO_MISS_ADDR  :
+                case CONTEXT_STATE_KO_PSYNC_ADDR :
+                case CONTEXT_STATE_KO_CSYNC_ADDR :
+                  {
+                    reg_STATE [i] = CONTEXT_STATE_OK;
+                    break;
+                  }
+                default :
+                  {
+        // -------------------------------------------------------------------
+        // -----[ BRANCH_EVENT ]----------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_context; ++i)
+          if (PORT_READ(in_BRANCH_EVENT_VAL [i]) and internal_BRANCH_EVENT_ACK [i])
+            {
+//               throw ERRORMORPHEO(FUNCTION,_("Not yet implemented (Comming Soon).\n"));
+              context_state_t state = reg_STATE [i];
+              Tdepth_t   depth      = // (_param->_have_port_depth)?PORT_READ(in_BRANCH_EVENT_DEPTH [i]):
+;
+              Tdepth_t   depth_cur  = reg_EVENT_DEPTH [i];
+              Tdepth_t   depth_min  = (_param->_have_port_depth)?PORT_READ(in_DEPTH_MIN [i]):0;
+              Tdepth_t   depth_max  = _param->_array_size_depth [i];
+//               Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur-depth_min):((depth_cur+depth_max-depth_min));
+//               Tdepth_t   depth1     = (depth    >=depth_min)?(depth    -depth_min):((depth    +depth_max-depth_min));
+              Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur):((depth_cur+depth_max));
+              Tdepth_t   depth1     = (depth    >=depth_min)?(depth    ):((depth    +depth_max));
+              // priority : miss > excep > spr/sync
+              uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == EVENT_TYPE_EXCEPTION)?1:0);
+              uint8_t    priority1  = 2; // miss
+              // is_valid = can modify local information
+              //   if context_state_ok : yes
+              //   if context_state_ko : test the depth, and the priority of envent
+              bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                       (depth1< depth0) or
+                                       ((depth1==depth0) and (priority1>priority0)));
+              if (is_valid)
+                {
+                  reg_STATE                  [i] =  CONTEXT_STATE_KO_MISS;
+                  reg_EVENT_ADDRESS          [i] =  PORT_READ(in_BRANCH_EVENT_ADDRESS_SRC [i])+1; // address delay slot
+                  reg_EVENT_ADDRESS_EPCR     [i] =  PORT_READ(in_BRANCH_EVENT_ADDRESS_DEST[i]);   // address_next
+                  reg_EVENT_ADDRESS_EPCR_VAL [i] =  1; // address_dest is valid
+                //reg_EVENT_ADDRESS_EEAR     [i] =  0;
+                  reg_EVENT_ADDRESS_EEAR_VAL [i] =  0;
+                  reg_EVENT_IS_DELAY_SLOT    [i] =  1;
+                  reg_EVENT_IS_DS_TAKE       [i] =  0;// ??
+                  reg_EVENT_DEPTH            [i] =  depth;
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ DECOD_EVENT ]-----------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+          if (PORT_READ(in_DECOD_EVENT_VAL [i]) and internal_DECOD_EVENT_ACK [i])
+            {
+              Tcontext_t context    = (_param->_have_port_context_id )?PORT_READ(in_DECOD_EVENT_CONTEXT_ID [i]):0;
+              Tdepth_t   depth      = (_param->_have_port_depth      )?PORT_READ(in_DECOD_EVENT_DEPTH      [i]):0;
+              Tdepth_t   depth_cur  = reg_EVENT_DEPTH [context];
+              Tdepth_t   depth_min = (_param->_have_port_depth      )?PORT_READ(in_DEPTH_MIN [context]):0;
+              Tdepth_t   depth_max  = _param->_array_size_depth [context];
+//               Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur-depth_min):((depth_cur+depth_max-depth_min));
+//               Tdepth_t   depth1     = (depth    >=depth_min)?(depth    -depth_min):((depth    +depth_max-depth_min));
+              Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur):((depth_cur+depth_max));
+              Tdepth_t   depth1     = (depth    >=depth_min)?(depth    ):((depth    +depth_max));
+              context_state_t state = reg_STATE [context];
+              Tevent_type_t   type  = PORT_READ(in_DECOD_EVENT_TYPE [i]);
+              // miss > excep > spr/sync
+              uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == CONTEXT_STATE_KO_EXCEP)?1:0);
+              uint8_t    priority1  = (state == EVENT_TYPE_EXCEPTION)?1:0;
+              // is_valid = can modify local information
+              //  if context_state_ok : yes
+              //  if context_state_ko : test the depth, and the priority of envent
+              bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                       (depth1< depth0) or
+                                       ((depth1==depth0) and (priority1>priority0)));
+              if (is_valid)
+                {
+                  // decod :
+                  // type : csync, psync, msync, spr_access (l.mac, l.maci, l.macrc, l.msb, l.mfspr, l.mtspr), exception (l.sys)
+                  context_state_t state_next    = state;
+                  Taddress_t      address       = PORT_READ(in_DECOD_EVENT_ADDRESS       [i]);
+                  Tcontrol_t      is_delay_slot = PORT_READ(in_DECOD_EVENT_IS_DELAY_SLOT [i]);
+                  switch (type)
+                    {
+                    case EVENT_TYPE_EXCEPTION          :
+                      {
+                        state_next = CONTEXT_STATE_KO_EXCEP;
+                        break;
+                      }
+                    case EVENT_TYPE_SPR_ACCESS         :
+                      {
+                        state_next = CONTEXT_STATE_KO_SPR  ;
+                        address++; // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_MSYNC              :
+                      {
+                        state_next = CONTEXT_STATE_KO_MSYNC;
+                        address++;  // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_PSYNC              :
+                      {
+                        state_next = CONTEXT_STATE_KO_PSYNC;
+                        address++;  // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_CSYNC              :
+                      {
+                        state_next = CONTEXT_STATE_KO_CSYNC;
+                        address++;  // take next address
+                        if (is_delay_slot)
+                          throw ERRORMORPHEO(FUNCTION,"SPR access in delay slot, not supported.\n");
+                        break;
+                      }
+                    case EVENT_TYPE_NONE               :
+                    case EVENT_TYPE_MISS_SPECULATION   :
+                    case EVENT_TYPE_BRANCH_NO_ACCURATE :
+                    default :
+                      {
+                        throw ERRORMORPHEO(FUNCTION,toString(_("DECOD_EVENT [%d] : invalid event_type : %s.\n"),i,toString(type).c_str()));
+                      }
+                    }
+                  reg_STATE                  [context] = state_next;
+                  reg_EVENT_ADDRESS          [context] = address;
+                  reg_EVENT_ADDRESS_EPCR     [context] = PORT_READ(in_DECOD_EVENT_ADDRESS_EPCR  [i]);
+                  reg_EVENT_ADDRESS_EPCR_VAL [context] = 1;
+                //reg_EVENT_ADDRESS_EEAR     [context]
+                  reg_EVENT_ADDRESS_EEAR_VAL [context] = 0;
+                  reg_EVENT_IS_DELAY_SLOT    [context] = is_delay_slot;
+                //reg_EVENT_IS_DS_TAKE       [context] = 0;
+                  reg_EVENT_DEPTH            [context] = depth;
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ COMMIT_EVENT ]----------------------------------------------
+        // -------------------------------------------------------------------
+        if (PORT_READ(in_COMMIT_EVENT_VAL ) and internal_COMMIT_EVENT_ACK )
+          {
+            Tcontext_t context    = (_param->_have_port_context_id)?PORT_READ(in_COMMIT_EVENT_CONTEXT_ID ):0;
+            Tdepth_t   depth      = (_param->_have_port_depth     )?PORT_READ(in_COMMIT_EVENT_DEPTH      ):0;
+            Tdepth_t   depth_cur  = reg_EVENT_DEPTH [context];
+            Tdepth_t   depth_min = (_param->_have_port_depth     )?PORT_READ(in_DEPTH_MIN [context]):0;
+            Tdepth_t   depth_max  = _param->_array_size_depth [context];
+//             Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur-depth_min):((depth_cur+depth_max-depth_min));
+//             Tdepth_t   depth1     = (depth    >=depth_min)?(depth    -depth_min):((depth    +depth_max-depth_min));
+            Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur):((depth_cur+depth_max));
+            Tdepth_t   depth1     = (depth    >=depth_min)?(depth    ):((depth    +depth_max));
+            context_state_t state = reg_STATE [context];
+            Tevent_type_t   type  = PORT_READ(in_COMMIT_EVENT_TYPE );
+            // miss > excep > spr/sync
+            uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == CONTEXT_STATE_KO_EXCEP)?1:0);
+            uint8_t    priority1  = 1; // exception
+            // is_valid = can modify local information
+            //  if context_state_ok : yes
+            //  if context_state_ko : test the depth, and the priority of envent
+            bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                     (depth1< depth0) or
+                                     ((depth1==depth0) and (priority1>priority0)));
+            if (is_valid)
+              {
+                // commit
+                // type : exception
+                context_state_t state_next = state;
+                switch (type)
+                  {
+                  case EVENT_TYPE_EXCEPTION          : {state_next = CONTEXT_STATE_KO_EXCEP; break;}
+                  case EVENT_TYPE_SPR_ACCESS         :
+                  case EVENT_TYPE_MSYNC              :
+                  case EVENT_TYPE_PSYNC              :
+                  case EVENT_TYPE_CSYNC              :
+                  case EVENT_TYPE_NONE               :
+                  case EVENT_TYPE_MISS_SPECULATION   :
+                  case EVENT_TYPE_BRANCH_NO_ACCURATE :
+                  default :
+                    {
+                      throw ERRORMORPHEO(FUNCTION,toString(_("COMMIT_EVENT : invalid event_type : %s.\n"),toString(type).c_str()));
+                    }
+                  }
+                reg_STATE                  [context] = state_next;
+                reg_EVENT_ADDRESS          [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS          );
+                reg_EVENT_ADDRESS_EPCR     [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS_EPCR     );
+                reg_EVENT_ADDRESS_EPCR_VAL [context] = 1;
+                reg_EVENT_ADDRESS_EEAR     [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS_EEAR     );
+                reg_EVENT_ADDRESS_EEAR_VAL [context] = PORT_READ(in_COMMIT_EVENT_ADDRESS_EEAR_VAL );
+                reg_EVENT_IS_DELAY_SLOT    [context] = PORT_READ(in_COMMIT_EVENT_IS_DELAY_SLOT    );
+              //reg_EVENT_IS_DS_TAKE       [context] = 0;
+                reg_EVENT_DEPTH            [context] = depth;
+              }
+          }
+        // -------------------------------------------------------------------
+        // -----[ BRANCH_COMPLETE ]-------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          if (PORT_READ(in_BRANCH_COMPLETE_VAL [i]) and internal_BRANCH_COMPLETE_ACK [i])
+            {
+              if (PORT_READ(in_BRANCH_COMPLETE_MISS_PREDICTION [i]))
+                {
+                  Tcontext_t context    = (_param->_have_port_context_id)?PORT_READ(in_BRANCH_COMPLETE_CONTEXT_ID [i]):0;
+                  Tdepth_t   depth      = (_param->_have_port_depth     )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
+                  Tdepth_t   depth_cur  = reg_EVENT_DEPTH [context];
+                  Tdepth_t   depth_min = (_param->_have_port_depth     )?PORT_READ(in_DEPTH_MIN [context]):0;
+                  Tdepth_t   depth_max  = _param->_array_size_depth [context];
+//                   Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur-depth_min):((depth_cur+depth_max-depth_min));
+//                   Tdepth_t   depth1     = (depth    >=depth_min)?(depth    -depth_min):((depth    +depth_max-depth_min));
+                  Tdepth_t   depth0     = (depth_cur>=depth_min)?(depth_cur):((depth_cur+depth_max));
+                  Tdepth_t   depth1     = (depth    >=depth_min)?(depth    ):((depth    +depth_max));
+                  context_state_t state = reg_STATE [context];
+                  // miss > excep > spr/sync
+                  uint8_t    priority0  = (state == CONTEXT_STATE_KO_MISS)?2:((state == CONTEXT_STATE_KO_EXCEP)?1:0);
+                  uint8_t    priority1  = 2; // miss
+                  // is_valid = can modify local information
+                  //  if context_state_ok : yes
+                  //  if context_state_ko : test the depth, and the priority of envent
+                  bool       is_valid   = ((state == CONTEXT_STATE_OK) or
+                                           (depth1< depth0) or
+                                           ((depth1==depth0) and (priority1>priority0)));
+                  if (is_valid)
+                    {
+                      // commit
+                      Tcontrol_t take = PORT_READ(in_BRANCH_COMPLETE_TAKE [i]);
+                      reg_STATE                  [context] = CONTEXT_STATE_KO_MISS;
+                      reg_EVENT_ADDRESS          [context] = PORT_READ(in_BRANCH_COMPLETE_ADDRESS_SRC  [i])+1; //DELAY_SLOT
+                      reg_EVENT_ADDRESS_EPCR     [context] = PORT_READ(in_BRANCH_COMPLETE_ADDRESS_DEST [i]);
+                      reg_EVENT_ADDRESS_EPCR_VAL [context] = take; // if not take : in sequence
+                    //reg_EVENT_ADDRESS_EEAR     [context];
+                      reg_EVENT_ADDRESS_EEAR_VAL [context] = 0;
+                      reg_EVENT_IS_DELAY_SLOT    [context] = take;
+                      reg_EVENT_IS_DS_TAKE       [context] = take;
+                      reg_EVENT_DEPTH            [context] = depth;
+                    }
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ EVENT ]-----------------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          if (internal_EVENT_VAL [i] and PORT_READ(in_EVENT_ACK [i]))
+            {
+              // Write pc
+              context_state_t state = reg_STATE [i];
+              switch (state)
+                {
+                case CONTEXT_STATE_KO_EXCEP_ADDR :
+                  {
+                    reg_STATE [i] = CONTEXT_STATE_KO_EXCEP_SPR;
+                    break;
+                  }
+                case CONTEXT_STATE_KO_MISS_ADDR  :
+                case CONTEXT_STATE_KO_PSYNC_ADDR :
+                case CONTEXT_STATE_KO_CSYNC_ADDR :
+                  {
+                    reg_STATE [i] = CONTEXT_STATE_OK;
+                    break;
+                  }
+                default :
+                  {
 #ifdef DEBUG_TEST
                     throw ERRORMORPHEO(FUNCTION,toString(_("SPR[%d], Invalid state : %s.\n"),i,toString(state).c_str()));
+                    throw ERRORMORPHEO(FUNCTION,toString(_("SPR[%d], Invalid state : %s.\n"),i,toString(state).c_str()));
 #endif
                     break;
+                  }
+                }
+            }
         // -------------------------------------------------------------------
         // -----[ SPR ]-------------------------------------------------------
         // -------------------------------------------------------------------
         for (uint32_t i=0; i<_param->_nb_context; i++)
           if (internal_SPR_VAL [i] and PORT_READ(in_SPR_ACK [i]))
+            {
               // Write spr
+                    break;
+                  }
+                }
+            }
+        // -------------------------------------------------------------------
+        // -----[ SPR_EVENT ]-------------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          if (internal_SPR_EVENT_VAL [i] and PORT_READ(in_SPR_EVENT_ACK [i]))
+            {
+              // Write spr
 #ifdef DEBUG_TEST
               context_state_t state = reg_STATE [i];
               if (state != CONTEXT_STATE_KO_EXCEP_SPR)
                 throw ERRORMORPHEO(FUNCTION,toString(_("SPR[%d], Invalid state : %s.\n"),i,toString(state).c_str()));
+              context_state_t state = reg_STATE [i];
+              if (state != CONTEXT_STATE_KO_EXCEP_SPR)
+                throw ERRORMORPHEO(FUNCTION,toString(_("SPR_EVENT[%d], Invalid state : %s.\n"),i,toString(state).c_str()));
 #endif
+              reg_STATE [i] = CONTEXT_STATE_OK;
+            }
+        // -------------------------------------------------------------------
+        // -----[ next state ]------------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            uint32_t x = _param->_link_context_to_decod_unit    [i];
+            uint32_t y = _param->_link_decod_unit_to_ooo_engine [x];
+            Tcounter_t inst_all = PORT_READ(in_NB_INST_COMMIT_ALL [y]) + PORT_READ(in_NB_INST_DECOD_ALL [x]);
+            Tcounter_t inst_mem = PORT_READ(in_NB_INST_COMMIT_MEM [y]) + PORT_READ(in_NB_INST_DECOD_ALL [x]);
+            context_state_t state = reg_STATE [i];
+            switch (state)
+              {
+              case CONTEXT_STATE_OK              :
+                {
+                  // nothing, wait an event
+                  break;
+                }
+              case CONTEXT_STATE_KO_EXCEP        :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_EXCEP_ADDR;
+                  break;
+                }
+              case CONTEXT_STATE_KO_MISS         :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_MISS_ADDR;
+                  break;
+                }
+              case CONTEXT_STATE_KO_EXCEP_ADDR   :
+                {
+                  // nothing, wait the update of internal register (pc)
+                  break;
+                }
+              case CONTEXT_STATE_KO_EXCEP_SPR    :
+                {
+                  // nothing, wait the update of internal register (epcr, eear, sr, esr)
+                  break;
+                }
+              case CONTEXT_STATE_KO_MISS_ADDR    :
+                {
+                  // nothing, wait the update of internal register (pc)
+                  break;
+                }
+              case CONTEXT_STATE_KO_PSYNC        :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+//                  state = CONTEXT_STATE_KO_PSYNC_FLUSH;
+                    state = CONTEXT_STATE_KO_PSYNC_ADDR ;
+                  break;
+                }
+//            case CONTEXT_STATE_KO_PSYNC_FLUSH  :
+//              {
+//                // nothing, wait end of flush (ifetch)
+//                break;
+//              }
+              case CONTEXT_STATE_KO_PSYNC_ADDR   :
+                {
+                  // nothing, wait the pc write
+                  break;
+                }
+              case CONTEXT_STATE_KO_CSYNC        :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_CSYNC_ADDR ;
+//                  state = CONTEXT_STATE_KO_CSYNC_FLUSH;
+                  break;
+                }
+//            case CONTEXT_STATE_KO_CSYNC_FLUSH  :
+//              {
+//                // nothing, wait end of flush (all internal structure)
+//                break;
+//              }
+              case CONTEXT_STATE_KO_CSYNC_ADDR   :
+                {
+                  // nothing, wait the pc write
+                  break;
+                }
+              case CONTEXT_STATE_KO_MSYNC        :
+                {
+                  // Wait end of memory instruction
+                  if (inst_mem == 0)
+                    state = CONTEXT_STATE_KO_MSYNC_ISSUE;
+                  break;
+                }
+              case CONTEXT_STATE_KO_MSYNC_ISSUE  :
+                {
+                  // Wait the msync issue
+                  if (inst_mem != 0)
+                    state = CONTEXT_STATE_KO_MSYNC_EXEC;
+                  break;
+                }
+              case CONTEXT_STATE_KO_MSYNC_EXEC   :
+                {
+                  // Wait the end of msync
+                  if (inst_mem == 0)
+                    state = CONTEXT_STATE_OK;
+                  break;
+                }
+              case CONTEXT_STATE_KO_SPR          :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_SPR_ISSUE;
+                  break;
+                }
+              case CONTEXT_STATE_KO_SPR_ISSUE    :
+                {
+                  // Wait the spr_access issue
+                  if (inst_all != 0)
+                    state = CONTEXT_STATE_KO_SPR_EXEC;
+                  break;
+                }
+              case CONTEXT_STATE_KO_SPR_EXEC     :
+                {
+                  // Wait the spr_access execution
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_OK;
+                  break;
+                }
+              default :
+                {
+                  throw ERRORMORPHEO(FUNCTION,toString(_("Context[%d], Unknow state : %s.\n"),i,toString(state).c_str()));
+                }
+              }
+            reg_STATE [i] = state;
+          }
+              reg_STATE [i] = CONTEXT_STATE_OK;
+            }
+        // -------------------------------------------------------------------
+        // -----[ next state ]------------------------------------------------
+        // -------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+//             uint32_t x = _param->_link_context_to_decod_unit    [i];
+            Tcounter_t inst_all = PORT_READ(in_NB_INST_COMMIT_ALL[i]) + PORT_READ(in_NB_INST_DECOD_ALL [i]);
+            Tcounter_t inst_mem = PORT_READ(in_NB_INST_COMMIT_MEM[i]) + PORT_READ(in_NB_INST_DECOD_ALL [i]);
+            context_state_t state = reg_STATE [i];
+            switch (state)
+              {
+              case CONTEXT_STATE_OK              :
+                {
+                  // nothing, wait an event
+                  break;
+                }
+              case CONTEXT_STATE_KO_EXCEP        :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_EXCEP_ADDR;
+                  break;
+                }
+              case CONTEXT_STATE_KO_MISS         :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_MISS_ADDR;
+                  break;
+                }
+              case CONTEXT_STATE_KO_EXCEP_ADDR   :
+                {
+                  // nothing, wait the update of internal register (pc)
+                  break;
+                }
+              case CONTEXT_STATE_KO_EXCEP_SPR    :
+                {
+                  // nothing, wait the update of internal register (epcr, eear, sr, esr)
+                  break;
+                }
+              case CONTEXT_STATE_KO_MISS_ADDR    :
+                {
+                  // nothing, wait the update of internal register (pc)
+                  break;
+                }
+              case CONTEXT_STATE_KO_PSYNC        :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+//                  state = CONTEXT_STATE_KO_PSYNC_FLUSH;
+                    state = CONTEXT_STATE_KO_PSYNC_ADDR ;
+                  break;
+                }
+//            case CONTEXT_STATE_KO_PSYNC_FLUSH  :
+//              {
+//                // nothing, wait end of flush (ifetch)
+//                break;
+//              }
+              case CONTEXT_STATE_KO_PSYNC_ADDR   :
+                {
+                  // nothing, wait the pc write
+                  break;
+                }
+              case CONTEXT_STATE_KO_CSYNC        :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_CSYNC_ADDR ;
+//                  state = CONTEXT_STATE_KO_CSYNC_FLUSH;
+                  break;
+                }
+//            case CONTEXT_STATE_KO_CSYNC_FLUSH  :
+//              {
+//                // nothing, wait end of flush (all internal structure)
+//                break;
+//              }
+              case CONTEXT_STATE_KO_CSYNC_ADDR   :
+                {
+                  // nothing, wait the pc write
+                  break;
+                }
+              case CONTEXT_STATE_KO_MSYNC        :
+                {
+                  // Wait end of memory instruction
+                  if (inst_mem == 0)
+                    state = CONTEXT_STATE_KO_MSYNC_ISSUE;
+                  break;
+                }
+              case CONTEXT_STATE_KO_MSYNC_ISSUE  :
+                {
+                  // Wait the msync issue
+                  if (inst_mem != 0)
+                    state = CONTEXT_STATE_KO_MSYNC_EXEC;
+                  break;
+                }
+              case CONTEXT_STATE_KO_MSYNC_EXEC   :
+                {
+                  // Wait the end of msync
+                  if (inst_mem == 0)
+                    state = CONTEXT_STATE_OK;
+                  break;
+                }
+              case CONTEXT_STATE_KO_SPR          :
+                {
+                  // Wait end of all instruction
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_KO_SPR_ISSUE;
+                  break;
+                }
+              case CONTEXT_STATE_KO_SPR_ISSUE    :
+                {
+                  // Wait the spr_access issue
+                  if (inst_all != 0)
+                    state = CONTEXT_STATE_KO_SPR_EXEC;
+                  break;
+                }
+              case CONTEXT_STATE_KO_SPR_EXEC     :
+                {
+                  // Wait the spr_access execution
+                  if (inst_all == 0)
+                    state = CONTEXT_STATE_OK;
+                  break;
+                }
+              default :
+                {
+                  throw ERRORMORPHEO(FUNCTION,toString(_("Context[%d], Unknow state : %s.\n"),i,toString(state).c_str()));
+                }
+              }
+            reg_STATE [i] = state;
+          }
+        for (uint32_t i=0; i<_param->_nb_context; ++i)
+          {
+            reg_INTERRUPT_ENABLE [i] = PORT_READ(in_INTERRUPT_ENABLE [i]) and PORT_READ(in_SPR_SR_IEE [i]);
+            if (reg_INTERRUPT_ENABLE [i])
+              throw ERRORMORPHEO(FUNCTION,toString(_("Context[%d], Have an interruption, Not yet supported (Comming Soon).\n"),i));
+          }
+      }
 …
     for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
         log_printf(TRACE,Context_State,FUNCTION,"Context State [%d]",i);
         log_printf(TRACE,Context_State,FUNCTION," * reg_STATE                  : %s"  ,toString(reg_STATE [i]).c_str());
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_ADDRESS          : 0x%x",reg_EVENT_ADDRESS          [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_ADDRESS_EPCR     : 0x%x",reg_EVENT_ADDRESS_EPCR     [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_ADDRESS_EPCR_VAL : %d"  ,reg_EVENT_ADDRESS_EPCR_VAL [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_ADDRESS_EEAR     : 0x%x",reg_EVENT_ADDRESS_EEAR     [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_ADDRESS_EEAR_VAL : %d"  ,reg_EVENT_ADDRESS_EEAR_VAL [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_IS_DELAY_SLOT    : %d"  ,reg_EVENT_IS_DELAY_SLOT    [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_IS_DS_TAKE       : %d"  ,reg_EVENT_IS_DS_TAKE       [i]);
         log_printf(TRACE,Context_State,FUNCTION," * reg_EVENT_DEPTH            : %d"  ,reg_EVENT_DEPTH            [i]);
+        log_printf(TRACE,Context_State,FUNCTION,"  * Dump Context State [%d]",i);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_STATE                  : %s"         ,toString(reg_STATE [i]).c_str());
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_ADDRESS          : 0x%x (0x%x)",reg_EVENT_ADDRESS          [i],reg_EVENT_ADDRESS      [i]<<2);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_ADDRESS_EPCR     : 0x%x (0x%x)",reg_EVENT_ADDRESS_EPCR     [i],reg_EVENT_ADDRESS_EPCR [i]<<2);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_ADDRESS_EPCR_VAL : %d"         ,reg_EVENT_ADDRESS_EPCR_VAL [i]);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_ADDRESS_EEAR     : 0x%x (0x%x)",reg_EVENT_ADDRESS_EEAR     [i],reg_EVENT_ADDRESS_EEAR [i]<<2);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_ADDRESS_EEAR_VAL : %d"         ,reg_EVENT_ADDRESS_EEAR_VAL [i]);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_IS_DELAY_SLOT    : %d"         ,reg_EVENT_IS_DELAY_SLOT    [i]);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_IS_DS_TAKE       : %d"         ,reg_EVENT_IS_DS_TAKE       [i]);
+        log_printf(TRACE,Context_State,FUNCTION,"    * reg_EVENT_DEPTH            : %d"         ,reg_EVENT_DEPTH            [i]);
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Parameters.cpp

-              r83
+              r88
   Parameters::Parameters (uint32_t   nb_context,
                           uint32_t   nb_decod_unit,
-                          uint32_t   nb_ooo_engine,
                           uint32_t   nb_inst_branch_complete,
                           uint32_t * size_depth,
                           uint32_t   size_address,
                           uint32_t * size_inst_decod,
                           uint32_t * size_inst_commit,
+                          uint32_t * size_nb_inst_decod,
+                          uint32_t   size_nb_inst_commit,
                           uint32_t * link_context_to_decod_unit,
                           uint32_t * link_decod_unit_to_ooo_engine)
+                          bool       is_toplevel)
+  {
     log_begin(Context_State,FUNCTION);
 …
     _nb_context                    = nb_context                   ;
     _nb_decod_unit                 = nb_decod_unit                ;
-    _nb_ooo_engine                 = nb_ooo_engine                ;
     _nb_inst_branch_complete       = nb_inst_branch_complete      ;
     _size_depth                    = size_depth                   ;
     _size_address                  = size_address                 ;
     _size_inst_decod               = size_inst_decod              ;
     _size_inst_commit              = size_inst_commit             ;
+    _array_size_depth              = size_depth                   ;
+//  _size_address                  = size_address                 ;
+//  _size_nb_inst_decod            = size_nb_inst_decod           ;
+//  _size_nb_inst_commit           = size_nb_inst_commit          ;
     _link_context_to_decod_unit    = link_context_to_decod_unit   ;
+    _link_decod_unit_to_ooo_engine = link_decod_unit_to_ooo_engine;
+    test();
+    if (is_toplevel)
+      {
+        _size_context_id               = log2(_nb_context);
+        _size_depth                    = log2(max<uint32_t>(size_depth,_nb_context));
+        _size_instruction_address      = size_address;
+        _size_nb_inst_decod            = max<uint32_t>(size_nb_inst_decod,_nb_decod_unit);
+        _size_nb_inst_commit           = size_nb_inst_commit;
+        _have_port_context_id          = (_size_context_id>0);
+        _have_port_depth               = (_size_depth > 0);
+        copy ();
+      }
-    _size_context_id               = log2(_nb_context);
-    _size_max_depth                = max<uint32_t>(_size_depth,_nb_context);
-    _have_port_context_id          = (_size_context_id>0);
-    _have_port_max_depth           = (_size_max_depth >0);
-    _have_port_depth               = new bool [_nb_context];
-    for (uint32_t i=0; i<_nb_context; i++)
-      _have_port_depth [i] = (_size_depth [i] >0);
-    test();
     log_end(Context_State,FUNCTION);
   };
 …
+  {
     log_begin(Context_State,FUNCTION);
+    delete [] _have_port_depth;
+    log_end(Context_State,FUNCTION);
+  };
+#undef  FUNCTION
+#define FUNCTION "Context_State::copy"
+  void Parameters::copy (void)
+  {
+    log_begin(Context_State,FUNCTION);
     log_end(Context_State,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Parameters_msg_error.cpp

-              r83
+              r88
         test.error(toString(_("The decod_unit [%d] have none context as source."),i));
-    bool _is_link_ooo_engine_from_decod_unit [_nb_ooo_engine];
-    for (uint32_t i=0; i<_nb_ooo_engine; i++)
-      _is_link_ooo_engine_from_decod_unit [i] = false;
-    for (uint32_t i=0; i<_nb_decod_unit; i++)
+      {
-        if (_link_decod_unit_to_ooo_engine [i] < _nb_ooo_engine)
-          _is_link_ooo_engine_from_decod_unit [_link_decod_unit_to_ooo_engine[i]] = true;
-        else
-          test.error(toString(_("The decod_unit [%d] is linked with invalid ooo_engine."),i));
+      }
-    for (uint32_t i=0; i<_nb_ooo_engine; i++)
-      if (_is_link_ooo_engine_from_decod_unit [i] == false)
-        test.error(toString(_("The ooo_engine [%d] have none decod_unit as source."),i));
     log_end(Context_State,FUNCTION);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Context_State/src/Parameters_print.cpp

-              r83
+              r88
     xml.balise_open("context_state");
     xml.singleton_begin("nb_context                   "); xml.attribut("value",toString(_nb_context                   )); xml.singleton_end();
+    xml.singleton_begin("nb_decod_unit                "); xml.attribut("value",toString(_nb_decod_unit                )); xml.singleton_end();
+    xml.singleton_begin("nb_ooo_engine                "); xml.attribut("value",toString(_nb_ooo_engine                )); xml.singleton_end();
+//  xml.singleton_begin("nb_decod_unit                "); xml.attribut("value",toString(_nb_decod_unit                )); xml.singleton_end();
     xml.singleton_begin("nb_inst_branch_complete      "); xml.attribut("value",toString(_nb_inst_branch_complete      )); xml.singleton_end();
+    xml.singleton_begin("size_address                 "); xml.attribut("value",toString(_size_address                 )); xml.singleton_end();
+//  xml.singleton_begin("size_address                 "); xml.attribut("value",toString(_size_address                 )); xml.singleton_end();
+//  xml.singleton_begin("size_inst_commit             "); xml.attribut("value",toString(_size_inst_commit             )); xml.singleton_end();
     for (uint32_t i=0;i<_nb_context; i++)
 …
         xml.  attribut("id"  ,toString(i));
         xml. balise_open_end();
         xml.  singleton_begin("size_depth                   "); xml.attribut("value",toString(_size_depth                    [i])); xml.singleton_end();
+//         xml.  singleton_begin("size_depth                   "); xml.attribut("value",toString(_size_depth                    [i])); xml.singleton_end();
         xml.  singleton_begin("link_context_to_decod_unit   "); xml.attribut("value",toString(_link_context_to_decod_unit    [i])); xml.singleton_end();
         xml. balise_close();
 …
         xml.  attribut("id"  ,toString(i));
         xml. balise_open_end();
+        xml.  singleton_begin("size_inst_decod              "); xml.attribut("value",toString(_size_inst_decod              [i])); xml.singleton_end();
+        xml.  singleton_begin("link_decod_unit_to_ooo_engine"); xml.attribut("value",toString(_link_decod_unit_to_ooo_engine[i])); xml.singleton_end();
+        xml. balise_close();
+      }
+    for (uint32_t i=0;i<_nb_ooo_engine; i++)
+      {
+        xml. balise_open_begin("component");
+        xml.  attribut("type","ooo_engine");
+        xml.  attribut("id"  ,toString(i));
+        xml. balise_open_end();
+        xml.  singleton_begin("size_inst_commit             "); xml.attribut("value",toString(_size_inst_commit             [i])); xml.singleton_end();
+//      xml.  singleton_begin("size_inst_decod              "); xml.attribut("value",toString(_size_inst_decod              [i])); xml.singleton_end();
         xml. balise_close();
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction/include/Types.h

-              r86
+              r88
     Ttype_t             _type              ;
     Toperation_t        _operation         ;
+    Tcontrol_t          _no_execute        ;
     Tcontrol_t          _has_immediat      ;
     Tgeneral_data_t     _immediat          ;
 …
     Tspecial_address_t  _num_reg_re        ;
     Texception_t        _exception_use     ;
+    Texception_t        _exception         ;
     Tbranch_condition_t _branch_condition  ;
 //     Tcontrol_t          _branch_stack_write;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction/src/Instruction.cpp

-              r86
+              r88
 #include "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction/include/Instruction.h"
 #include "Behavioural/include/Constants.h"
+#include "Behavioural/include/Operation.h"
 namespace morpheo {
 …
     inst->_exception_use = EXCEPTION_USE_ILLEGAL_INSTRUCTION;
+    inst->_exception     = EXCEPTION_ILLEGAL_INSTRUCTION;
     if (inst->_is_delay_slot)
 …
     uint32_t opcod = range<uint32_t>(inst->_instruction,31,26);
+    inst->_type = TYPE_CUSTOM;
     switch (opcod)
+      {
+      case OPCOD_L_CUST1 : {inst->_operation = OPERATION_CUSTOM_L_1; break;}
+      case OPCOD_L_CUST2 : {inst->_operation = OPERATION_CUSTOM_L_2; break;}
+      case OPCOD_L_CUST3 : {inst->_operation = OPERATION_CUSTOM_L_3; break;}
+      case OPCOD_L_CUST4 : {inst->_operation = OPERATION_CUSTOM_L_4; break;}
+      case OPCOD_L_CUST5 : {inst->_operation = OPERATION_CUSTOM_L_5; break;}
+      case OPCOD_L_CUST6 : {inst->_operation = OPERATION_CUSTOM_L_6; break;}
+      case OPCOD_L_CUST7 : {inst->_operation = OPERATION_CUSTOM_L_7; break;}
+      case OPCOD_L_CUST8 : {inst->_operation = OPERATION_CUSTOM_L_8; break;}
+      case OPCOD_L_CUST1 : {inst->_type = instruction_information(INSTRUCTION_L_CUST1)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST1)._operation; break;}
+      case OPCOD_L_CUST2 : {inst->_type = instruction_information(INSTRUCTION_L_CUST2)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST2)._operation; break;}
+      case OPCOD_L_CUST3 : {inst->_type = instruction_information(INSTRUCTION_L_CUST3)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST3)._operation; break;}
+      case OPCOD_L_CUST4 : {inst->_type = instruction_information(INSTRUCTION_L_CUST4)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST4)._operation; break;}
+      case OPCOD_L_CUST5 : {inst->_type = instruction_information(INSTRUCTION_L_CUST5)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST5)._operation; break;}
+      case OPCOD_L_CUST6 : {inst->_type = instruction_information(INSTRUCTION_L_CUST6)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST6)._operation; break;}
+      case OPCOD_L_CUST7 : {inst->_type = instruction_information(INSTRUCTION_L_CUST7)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST7)._operation; break;}
+      case OPCOD_L_CUST8 : {inst->_type = instruction_information(INSTRUCTION_L_CUST8)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST8)._operation; break;}
       default            : {throw ERRORMORPHEO("instruction_l_custom",_("Invalid Custom Opcod."));}
+      }
 …
     uint32_t opcod = range<uint32_t>(inst->_instruction, 7, 0);
-    inst->_type = TYPE_CUSTOM;
     switch (opcod)
+      {
 //       case OPCOD_LF_CUST1_D : {inst->_operation = OPERATION_CUSTOM_LF_1_D; break;}
 //       case OPCOD_LF_CUST1_S : {inst->_operation = OPERATION_CUSTOM_LF_1_S; break;}
+//       case OPCOD_LF_CUST1_D : {inst->_type = instruction_information(INSTRUCTION_LF_CUST1_D)._type; inst->_operation = instruction_information(INSTRUCTION_LF_CUST1_D)._operation; break;}
+//       case OPCOD_LF_CUST1_S : {inst->_type = instruction_information(INSTRUCTION_LF_CUST1_S)._type; inst->_operation = instruction_information(INSTRUCTION_LF_CUST1_S)._operation; break;}
       default               : {throw ERRORMORPHEO("instruction_lf_custom",_("Invalid Custom Opcod."));}
+      }
 …
     uint32_t opcod = range<uint32_t>(inst->_instruction, 7, 0);
-    inst->_type = TYPE_CUSTOM;
     switch (opcod)
+      {
 //       case OPCOD_LV_CUST1 : {inst->_operation = OPERATION_CUSTOM_LV_1; break;}
 //       case OPCOD_LV_CUST2 : {inst->_operation = OPERATION_CUSTOM_LV_2; break;}
 //       case OPCOD_LV_CUST3 : {inst->_operation = OPERATION_CUSTOM_LV_3; break;}
 //       case OPCOD_LV_CUST4 : {inst->_operation = OPERATION_CUSTOM_LV_4; break;}
+//       case OPCOD_LV_CUST1 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST1)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST1)._operation; break;}
+//       case OPCOD_LV_CUST2 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST2)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST2)._operation; break;}
+//       case OPCOD_LV_CUST3 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST3)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST3)._operation; break;}
+//       case OPCOD_LV_CUST4 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST4)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST4)._operation; break;}
       default             : {throw ERRORMORPHEO("instruction_lv_custom",_("Invalid Custom Opcod."));}
+      }
 …
+  {
     log_printf(TRACE,Decod,"instruction_l_add","  * instruction   : l.add");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_ADD;
+    inst->_type               = instruction_information(INSTRUCTION_L_ADD)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ADD)._operation; //OPERATION_ALU_L_ADD;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_addc","  * instruction   : l.addc");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_ADD;
+    inst->_type               = instruction_information(INSTRUCTION_L_ADDC)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ADDC)._operation; //OPERATION_ALU_L_ADD;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_addi","  * instruction   : l.addi");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_ADD;
+    inst->_type               = instruction_information(INSTRUCTION_L_ADDI)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ADDI)._operation; //OPERATION_ALU_L_ADD;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_addic","  * instruction   : l.addic");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_ADD;
+    inst->_type               = instruction_information(INSTRUCTION_L_ADDIC)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ADDIC)._operation; //OPERATION_ALU_L_ADD;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_and","  * instruction   : l.and");
+    inst->_type               = TYPE_ALU;
+    inst->_operation          = OPERATION_ALU_L_AND;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_AND)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_AND)._operation; //OPERATION_ALU_L_AND;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_andi","  * instruction   : l.andi");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_AND;
+    inst->_type               = instruction_information(INSTRUCTION_L_ANDI)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ANDI)._operation; //OPERATION_ALU_L_AND;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_bf","  * instruction   : l.bf");
+    Tgeneral_data_t address_next = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
+    inst->_type               = TYPE_BRANCH;
+    inst->_operation          = OPERATION_BRANCH_L_TEST_F;
+    Tgeneral_data_t address_next = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
+                                                   );
+    inst->_type               = instruction_information(INSTRUCTION_L_BF)._type     ; //TYPE_BRANCH;
+    inst->_operation          = instruction_information(INSTRUCTION_L_BF)._operation; //OPERATION_BRANCH_L_TEST_F;
     inst->_has_immediat       = 1;
     inst->_immediat           = address_next;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
     inst->_branch_condition   = BRANCH_CONDITION_FLAG_SET;
 //  inst->_branch_stack_write = 0;
 …
     inst->_branch_direction   = range<Tgeneral_data_t   >(inst->_instruction,25,25);
     inst->_address_next       = address_next;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_bnf","  * instruction   : l.bnf");
+    Tgeneral_data_t address_next = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
+    inst->_type               = TYPE_BRANCH;
+    inst->_operation          = OPERATION_BRANCH_L_TEST_NF;
+    Tgeneral_data_t address_next = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
+                                                   );
+    inst->_type               = instruction_information(INSTRUCTION_L_BNF)._type     ; //TYPE_BRANCH;
+    inst->_operation          = instruction_information(INSTRUCTION_L_BNF)._operation; //OPERATION_BRANCH_L_TEST_NF;
     inst->_has_immediat       = 1;
     inst->_immediat           = address_next;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
     inst->_branch_condition   = BRANCH_CONDITION_FLAG_UNSET;
 //  inst->_branch_stack_write = 0;
     inst->_branch_direction   = range<Tgeneral_data_t   >(inst->_instruction,25,25);
     inst->_address_next       = address_next;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_cmov","  * instruction   : l.cmov");
     inst->_type               = TYPE_MOVE;
     inst->_operation          = OPERATION_MOVE_L_CMOV;
+    inst->_type               = instruction_information(INSTRUCTION_L_CMOV)._type     ; //TYPE_MOVE;
+    inst->_operation          = instruction_information(INSTRUCTION_L_CMOV)._operation; //OPERATION_MOVE_L_CMOV;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     else
+      {
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_CSYNC;
+    inst->_type               = instruction_information(INSTRUCTION_L_CSYNC)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_CSYNC)._operation; //OPERATION_SPECIAL_L_CSYNC;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_CSYNC;
+      }
 …
     log_printf(TRACE,Decod,"instruction_l_div","  * instruction   : l.div");
     inst->_type               = TYPE_MUL_DIV;
     inst->_operation          = OPERATION_MUL_DIV_L_DIV;
+    inst->_type               = instruction_information(INSTRUCTION_L_DIV)._type     ; //TYPE_DIV;
+    inst->_operation          = instruction_information(INSTRUCTION_L_DIV)._operation; //OPERATION_DIV_L_DIV;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_divu","  * instruction   : l.divu");
     inst->_type               = TYPE_MUL_DIV;
     inst->_operation          = OPERATION_MUL_DIV_L_DIVU;
+    inst->_type               = instruction_information(INSTRUCTION_L_DIVU)._type     ; //TYPE_DIV;
+    inst->_operation          = instruction_information(INSTRUCTION_L_DIVU)._operation; //OPERATION_DIV_L_DIVU;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_extbs","  * instruction   : l.extbs");
     inst->_type               = TYPE_EXTEND;
     inst->_operation          = OPERATION_EXTEND_L_EXTEND_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_EXTBS)._type     ; //TYPE_EXTEND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_EXTBS)._operation; //OPERATION_EXTEND_L_EXTEND_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = 8;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_extbz","  * instruction   : l.extbz");
     inst->_type               = TYPE_EXTEND;
     inst->_operation          = OPERATION_EXTEND_L_EXTEND_Z;
+    inst->_type               = instruction_information(INSTRUCTION_L_EXTBZ)._type     ; //TYPE_EXTEND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_EXTBZ)._operation; //OPERATION_EXTEND_L_EXTEND_Z;
     inst->_has_immediat       = 1;
     inst->_immediat           = 8;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_exths","  * instruction   : l.exths");
     inst->_type               = TYPE_EXTEND;
     inst->_operation          = OPERATION_EXTEND_L_EXTEND_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_EXTHS)._type     ; //TYPE_EXTEND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_EXTHS)._operation; //OPERATION_EXTEND_L_EXTEND_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = 16;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_exthz","  * instruction   : l.exthz");
     inst->_type               = TYPE_EXTEND;
     inst->_operation          = OPERATION_EXTEND_L_EXTEND_Z;
+    inst->_type               = instruction_information(INSTRUCTION_L_EXTHZ)._type     ; //TYPE_EXTEND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_EXTHZ)._operation; //OPERATION_EXTEND_L_EXTEND_Z;
     inst->_has_immediat       = 1;
     inst->_immediat           = 16;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_extws","  * instruction   : l.extws");
     inst->_type               = TYPE_EXTEND;
     inst->_operation          = OPERATION_EXTEND_L_EXTEND_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_EXTWS)._type     ; //TYPE_EXTEND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_EXTWS)._operation; //OPERATION_EXTEND_L_EXTEND_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = 32;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_extwz","  * instruction   : l.extwz");
     inst->_type               = TYPE_EXTEND;
     inst->_operation          = OPERATION_EXTEND_L_EXTEND_Z;
+    inst->_type               = instruction_information(INSTRUCTION_L_EXTWZ)._type     ; //TYPE_EXTEND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_EXTWZ)._operation; //OPERATION_EXTEND_L_EXTEND_Z;
     inst->_has_immediat       = 1;
     inst->_immediat           = 32;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_ff1","  * instruction   : l.ff1");
+    inst->_type               = TYPE_FIND;
+    inst->_operation          = OPERATION_FIND_L_FF1;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 0;
+//  inst->_num_reg_rb         = ;
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_FF1)._type     ; //TYPE_FIND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_FF1)._operation; //OPERATION_FIND_L_FF1;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 0;
+//  inst->_num_reg_rb         = ;
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_fl1","  * instruction   : l.fl1");
+    inst->_type               = TYPE_FIND;
+    inst->_operation          = OPERATION_FIND_L_FL1;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 0;
+//  inst->_num_reg_rb         = ;
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_FL1)._type     ; //TYPE_FIND;
+    inst->_operation          = instruction_information(INSTRUCTION_L_FL1)._operation; //OPERATION_FIND_L_FL1;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 0;
+//  inst->_num_reg_rb         = ;
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_j","  * instruction   : l.j");
     inst->_type               = TYPE_BRANCH;
     inst->_operation          = OPERATION_BRANCH_NONE;
+    inst->_type               = instruction_information(INSTRUCTION_L_J)._type     ; //TYPE_BRANCH;
+    inst->_operation          = instruction_information(INSTRUCTION_L_J)._operation; //OPERATION_BRANCH_NONE;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
     inst->_branch_condition   = BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK;
 //  inst->_branch_stack_write = 0;
     inst->_branch_direction   = 1;
+    inst->_address_next       = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
+    inst->_address_next       = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
+                                                               );
+    inst->_no_execute         = 1;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_jal","  * instruction   : l.jal");
     inst->_type               = TYPE_BRANCH;
     inst->_operation          = OPERATION_BRANCH_L_JALR;
+    inst->_type               = instruction_information(INSTRUCTION_L_JAL)._type     ; //TYPE_BRANCH;
+    inst->_operation          = instruction_information(INSTRUCTION_L_JAL)._operation; //OPERATION_BRANCH_L_JALR;
     inst->_has_immediat       = 1;
     inst->_immediat           = inst->_address_next+1;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
     inst->_branch_condition   = BRANCH_CONDITION_NONE_WITH_WRITE_STACK; // Always jump
 //  inst->_branch_stack_write = 1;
     inst->_branch_direction   = 1;
+    inst->_address_next       = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
+    inst->_address_next       = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
+                                                );
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     else
+      {
     inst->_type               = TYPE_BRANCH;
     inst->_operation          = OPERATION_BRANCH_L_JALR;
+    inst->_type               = instruction_information(INSTRUCTION_L_JALR)._type     ; //TYPE_BRANCH;
+    inst->_operation          = instruction_information(INSTRUCTION_L_JALR)._operation; //OPERATION_BRANCH_L_JALR;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = (inst->_num_reg_rb == 9)?BRANCH_CONDITION_READ_STACK:BRANCH_CONDITION_READ_REGISTER;
     inst->_branch_condition   = BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK;
 …
     inst->_branch_direction   = 1;
 //  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+      }
 …
     log_printf(TRACE,Decod,"instruction_l_jr","  * instruction   : l.jr");
     inst->_type               = TYPE_BRANCH;
     inst->_operation          = OPERATION_BRANCH_L_JALR;
+    inst->_type               = instruction_information(INSTRUCTION_L_JR)._type     ; //TYPE_BRANCH;
+    inst->_operation          = instruction_information(INSTRUCTION_L_JR)._operation; //OPERATION_BRANCH_L_JALR;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
     inst->_branch_condition   = (inst->_num_reg_rb == 9)?BRANCH_CONDITION_READ_STACK:BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK;
 //  inst->_branch_stack_write = 0;
     inst->_branch_direction   = 1;
 //  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_lbs","  * instruction   : l.lbs");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_8_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_LBS)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LBS)._operation; //OPERATION_MEMORY_LOAD_8_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_lbz","  * instruction   : l.lbz");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_8_Z;
+    inst->_type               = instruction_information(INSTRUCTION_L_LBZ)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LBZ)._operation; //OPERATION_MEMORY_LOAD_8_Z;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_ld","  * instruction   : l.ld");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_64_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_LD)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LD)._operation; //OPERATION_MEMORY_LOAD_64_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_lhs","  * instruction   : l.lhs");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_16_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_LHS)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LHS)._operation; //OPERATION_MEMORY_LOAD_16_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_lhz","  * instruction   : l.lhz");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_16_Z;
+    inst->_type               = instruction_information(INSTRUCTION_L_LHZ)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LHZ)._operation; //OPERATION_MEMORY_LOAD_16_Z;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_lws","  * instruction   : l.lws");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_32_S;
+    inst->_type               = instruction_information(INSTRUCTION_L_LWS)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LWS)._operation; //OPERATION_MEMORY_LOAD_32_S;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_lwz","  * instruction   : l.lwz");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_LOAD_32_Z;
+    inst->_type               = instruction_information(INSTRUCTION_L_LWZ)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_LWZ)._operation; //OPERATION_MEMORY_LOAD_32_Z;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_mac","  * instruction   : l.mac");
+    inst->_type               = TYPE_SPECIAL;
+    inst->_operation          = OPERATION_SPECIAL_L_MAC;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 0;
+//  inst->_num_reg_rd         = ;
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_type               = instruction_information(INSTRUCTION_L_MAC)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MAC)._operation; //OPERATION_SPECIAL_L_MAC;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 0;
+//  inst->_num_reg_rd         = ;
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_maci","  * instruction   : l.maci");
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_MAC;
+    inst->_type               = instruction_information(INSTRUCTION_L_MACI)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MACI)._operation; //OPERATION_SPECIAL_L_MAC;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
+  }
 …
     else
+      {
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_MACRC;
+    inst->_type               = instruction_information(INSTRUCTION_L_MACRC)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MACRC)._operation; //OPERATION_SPECIAL_L_MACRC;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
+      }
 …
     log_printf(TRACE,Decod,"instruction_l_mfspr","  * instruction   : l.mfspr");
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_MFSPR;
+    inst->_type               = instruction_information(INSTRUCTION_L_MFSPR)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MFSPR)._operation; //OPERATION_SPECIAL_L_MFSPR;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_movhi","  * instruction   : l.movhi");
     inst->_type               = TYPE_MOVE;
     inst->_operation          = OPERATION_MOVE_L_MOVHI;
+    inst->_type               = instruction_information(INSTRUCTION_L_MOVHI)._type     ; //TYPE_MOVE;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MOVHI)._operation; //OPERATION_MOVE_L_MOVHI;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_msb","  * instruction   : l.msb");
+    inst->_type               = TYPE_SPECIAL;
+    inst->_operation          = OPERATION_SPECIAL_L_MSB;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 0;
+//  inst->_num_reg_rd         = ;
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_type               = instruction_information(INSTRUCTION_L_MSB)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MSB)._operation; //OPERATION_SPECIAL_L_MSB;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 0;
+//  inst->_num_reg_rd         = ;
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
+  }
 …
     else
+      {
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_MSYNC;
+    inst->_type               = instruction_information(INSTRUCTION_L_MSYNC)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MSYNC)._operation; //OPERATION_SPECIAL_L_MSYNC;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_MSYNC;
+      }
 …
     log_printf(TRACE,Decod,"instruction_l_mtspr","  * instruction   : l.mtspr");
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_MTSPR;
+    inst->_type               = instruction_information(INSTRUCTION_L_MTSPR)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MTSPR)._operation; //OPERATION_SPECIAL_L_MTSPR;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDZ(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_mul","  * instruction   : l.mul");
     inst->_type               = TYPE_MUL_DIV;
     inst->_operation          = OPERATION_MUL_DIV_L_MUL;
+    inst->_type               = instruction_information(INSTRUCTION_L_MUL)._type     ; //TYPE_MUL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MUL)._operation; //OPERATION_MUL_L_MUL;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_muli","  * instruction   : l.muli");
     inst->_type               = TYPE_MUL_DIV;
     inst->_operation          = OPERATION_MUL_DIV_L_MUL;
+    inst->_type               = instruction_information(INSTRUCTION_L_MULI)._type     ; //TYPE_MUL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MULI)._operation; //OPERATION_MUL_L_MUL;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_mulu","  * instruction   : l.mulu");
     inst->_type               = TYPE_MUL_DIV;
     inst->_operation          = OPERATION_MUL_DIV_L_MULU;
+    inst->_type               = instruction_information(INSTRUCTION_L_MULU)._type     ; //TYPE_MUL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_MULU)._operation; //OPERATION_MUL_L_MULU;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_nop","  * instruction   : l.nop");
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_NOP;
+    inst->_type               = instruction_information(INSTRUCTION_L_NOP)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_NOP)._operation; //OPERATION_SPECIAL_L_NOP;
 //  inst->_has_immediat       = 1;
 //  inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 1;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_or","  * instruction   : l.or");
+    inst->_type               = TYPE_ALU;
+    inst->_operation          = OPERATION_ALU_L_OR;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_OR)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_OR)._operation; //OPERATION_ALU_L_OR;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_ori","  * instruction   : l.ori");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_OR;
+    inst->_type               = instruction_information(INSTRUCTION_L_ORI)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ORI)._operation; //OPERATION_ALU_L_OR;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     else
+      {
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_PSYNC;
+    inst->_type               = instruction_information(INSTRUCTION_L_PSYNC)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_PSYNC)._operation; //OPERATION_SPECIAL_L_PSYNC;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_PSYNC;
+      }
 …
     log_printf(TRACE,Decod,"instruction_l_rfe","  * instruction   : l.rfe");
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_RFE;
+    inst->_type               = instruction_information(INSTRUCTION_L_RFE)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_RFE)._operation; //OPERATION_SPECIAL_L_RFE;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 //  inst->_branch_direction   = ;
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 1;
     inst->_event_type         = EVENT_TYPE_NONE; // can't anticip this instruction : must read EPCR in rename stage
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_ror","  * instruction   : l.ror");
+    inst->_type               = TYPE_SHIFT;
+    inst->_operation          = OPERATION_SHIFT_L_ROR;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_ROR)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_ROR)._operation; //OPERATION_SHIFT_L_ROR;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_rori","  * instruction   : l.rori");
     inst->_type               = TYPE_SHIFT;
     inst->_operation          = OPERATION_SHIFT_L_ROR;
+    inst->_type               = instruction_information(INSTRUCTION_L_RORI)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_RORI)._operation; //OPERATION_SHIFT_L_ROR;
     inst->_has_immediat       = 1;
     inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sb","  * instruction   : l.sb");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_STORE_8;
+    inst->_type               = instruction_information(INSTRUCTION_L_SB)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SB)._operation; //OPERATION_MEMORY_STORE_8;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sb","  * instruction   : l.sb");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_STORE_64;
+    inst->_type               = instruction_information(INSTRUCTION_L_SD)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SD)._operation; //OPERATION_MEMORY_STORE_64;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfeq","  * instruction   : l.sfeq");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFEQ;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFEQ)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFEQ)._operation; //OPERATION_TEST_L_SFEQ;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfeqi","  * instruction   : l.sfeqi");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFEQ;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFEQI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFEQI)._operation; //OPERATION_TEST_L_SFEQ;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfges","  * instruction   : l.sfges");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGES;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGES)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGES)._operation; //OPERATION_TEST_L_SFGES;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgesi","  * instruction   : l.sfgesi");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGES;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGESI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGESI)._operation; //OPERATION_TEST_L_SFGES;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgeu","  * instruction   : l.sfgeu");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGEU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGEU)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGEU)._operation; //OPERATION_TEST_L_SFGEU;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgeui","  * instruction   : l.sfgeui");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGEU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGEUI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGEUI)._operation; //OPERATION_TEST_L_SFGEU;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgts","  * instruction   : l.sfgts");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGTS;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGTS)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTS)._operation; //OPERATION_TEST_L_SFGTS;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgtsi","  * instruction   : l.sfgtsi");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGTS;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGTSI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTSI)._operation; //OPERATION_TEST_L_SFGTS;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgtu","  * instruction   : l.sfgtu");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGTU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGTU)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTU)._operation; //OPERATION_TEST_L_SFGTU;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfgtui","  * instruction   : l.sfgtui");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFGTU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFGTUI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTUI)._operation; //OPERATION_TEST_L_SFGTU;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfles","  * instruction   : l.sfles");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLES;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLES)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLES)._operation; //OPERATION_TEST_L_SFLES;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sflesi","  * instruction   : l.sflesi");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLES;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLESI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLESI)._operation; //OPERATION_TEST_L_SFLES;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfleu","  * instruction   : l.sfleu");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLEU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLEU)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLEU)._operation; //OPERATION_TEST_L_SFLEU;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfleui","  * instruction   : l.sfleui");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLEU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLEUI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLEUI)._operation; //OPERATION_TEST_L_SFLEU;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sflts","  * instruction   : l.sflts");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLTS;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLTS)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTS)._operation; //OPERATION_TEST_L_SFLTS;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfltsi","  * instruction   : l.sfltsi");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLTS;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLTSI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTSI)._operation; //OPERATION_TEST_L_SFLTS;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfltu","  * instruction   : l.sfltu");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLTU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLTU)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTU)._operation; //OPERATION_TEST_L_SFLTU;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfltui","  * instruction   : l.sfltui");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFLTU;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFLTUI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTUI)._operation; //OPERATION_TEST_L_SFLTU;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfne","  * instruction   : l.sfne");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFNE;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFNE)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFNE)._operation; //OPERATION_TEST_L_SFNE;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sfnei","  * instruction   : l.sfnei");
     inst->_type               = TYPE_TEST;
     inst->_operation          = OPERATION_TEST_L_SFNE;
+    inst->_type               = instruction_information(INSTRUCTION_L_SFNEI)._type     ; //TYPE_TEST;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SFNEI)._operation; //OPERATION_TEST_L_SFNE;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_F;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sh","  * instruction   : l.sh");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_STORE_16;
+    inst->_type               = instruction_information(INSTRUCTION_L_SH)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SH)._operation; //OPERATION_MEMORY_STORE_16;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sll","  * instruction   : l.sll");
+    inst->_type               = TYPE_SHIFT;
+    inst->_operation          = OPERATION_SHIFT_L_SLL;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_SLL)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SLL)._operation; //OPERATION_SHIFT_L_SLL;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_slli","  * instruction   : l.slli");
     inst->_type               = TYPE_SHIFT;
     inst->_operation          = OPERATION_SHIFT_L_SLL;
+    inst->_type               = instruction_information(INSTRUCTION_L_SLLI)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SLLI)._operation; //OPERATION_SHIFT_L_SLL;
     inst->_has_immediat       = 1;
     inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sra","  * instruction   : l.sra");
+    inst->_type               = TYPE_SHIFT;
+    inst->_operation          = OPERATION_SHIFT_L_SRA;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_SRA)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SRA)._operation; //OPERATION_SHIFT_L_SRA;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_srai","  * instruction   : l.srai");
     inst->_type               = TYPE_SHIFT;
     inst->_operation          = OPERATION_SHIFT_L_SRA;
+    inst->_type               = instruction_information(INSTRUCTION_L_SRAI)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SRAI)._operation; //OPERATION_SHIFT_L_SRA;
     inst->_has_immediat       = 1;
     inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_srl","  * instruction   : l.srl");
+    inst->_type               = TYPE_SHIFT;
+    inst->_operation          = OPERATION_SHIFT_L_SRL;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_SRL)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SRL)._operation; //OPERATION_SHIFT_L_SRL;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_srli","  * instruction   : l.srli");
     inst->_type               = TYPE_SHIFT;
     inst->_operation          = OPERATION_SHIFT_L_SRL;
+    inst->_type               = instruction_information(INSTRUCTION_L_SRLI)._type     ; //TYPE_SHIFT;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SRLI)._operation; //OPERATION_SHIFT_L_SRL;
     inst->_has_immediat       = 1;
     inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sub","  * instruction   : l.sub");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_SUB;
+    inst->_type               = instruction_information(INSTRUCTION_L_SUB)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SUB)._operation; //OPERATION_ALU_L_SUB;
     inst->_has_immediat       = 0;
 //  inst->_immediat           = ;
 …
     inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
     inst->_exception_use      = EXCEPTION_USE_RANGE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_sw","  * instruction   : l.sw");
     inst->_type               = TYPE_MEMORY;
     inst->_operation          = OPERATION_MEMORY_STORE_32;
+    inst->_type               = instruction_information(INSTRUCTION_L_SW)._type     ; //TYPE_MEMORY;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SW)._operation; //OPERATION_MEMORY_STORE_32;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     else
+      {
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_SYS;
+    inst->_type               = instruction_information(INSTRUCTION_L_SYS)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_SYS)._operation; //OPERATION_SPECIAL_L_SYS;
 //  inst->_has_immediat       = 1;
 //  inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_SYSCALL;
+    inst->_exception          = EXCEPTION_SYSCALL;
 //  inst->_branch_condition   = ;
 //  inst->_branch_stack_write = ;
 …
 //  inst->_address_next       = ; // don't change
+    inst->_no_execute         = 1;
     inst->_event_type         = EVENT_TYPE_EXCEPTION;
+      }
 …
     else
+      {
     inst->_type               = TYPE_SPECIAL;
     inst->_operation          = OPERATION_SPECIAL_L_TRAP;
+    inst->_type               = instruction_information(INSTRUCTION_L_TRAP)._type     ; //TYPE_SPECIAL;
+    inst->_operation          = instruction_information(INSTRUCTION_L_TRAP)._operation; //OPERATION_SPECIAL_L_TRAP;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDZ(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_TRAP;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 1;
     inst->_event_type         = EVENT_TYPE_NONE;
+      }
 …
     log_printf(TRACE,Decod,"instruction_l_xor","  * instruction   : l.xor");
+    inst->_type               = TYPE_ALU;
+    inst->_operation          = OPERATION_ALU_L_XOR;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_type               = instruction_information(INSTRUCTION_L_XOR)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_XOR)._operation; //OPERATION_ALU_L_XOR;
+    inst->_has_immediat       = 0;
+//  inst->_immediat           = ;
+    inst->_read_ra            = 1;
+    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
+    inst->_read_rb            = 1;
+    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
+    inst->_read_rc            = 0;
+//  inst->_num_reg_rc         = ;
+    inst->_write_rd           = 1;
+    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
+    inst->_write_re           = 0;
+//  inst->_num_reg_re         = ;
+    inst->_exception_use      = EXCEPTION_USE_NONE;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }
 …
     log_printf(TRACE,Decod,"instruction_l_xori","  * instruction   : l.xori");
     inst->_type               = TYPE_ALU;
     inst->_operation          = OPERATION_ALU_L_XOR;
+    inst->_type               = instruction_information(INSTRUCTION_L_XORI)._type     ; //TYPE_ALU;
+    inst->_operation          = instruction_information(INSTRUCTION_L_XORI)._operation; //OPERATION_ALU_L_XOR;
     inst->_has_immediat       = 1;
     inst->_immediat           = EXTENDS(inst->_instruction,16);
 …
 //  inst->_num_reg_re         = ;
     inst->_exception_use      = EXCEPTION_USE_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_exception          = EXCEPTION_DECOD_NONE;
+//  inst->_branch_condition   = ;
+//  inst->_branch_stack_write = ;
+//  inst->_branch_direction   = ;
+//  inst->_address_next       = ;
+    inst->_no_execute         = 0;
     inst->_event_type         = EVENT_TYPE_NONE;
+  }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Makefile.deps

-              r81
+              r88
 include                         $(DIR_MORPHEO)/Behavioural/Makefile.deps
 endif
+ifndef Priority
+include                         $(DIR_MORPHEO)/Behavioural/Generic/Priority/Makefile.deps
+endif
 ifndef Custom
 include                         $(DIR_MORPHEO)/Behavioural/Custom/Makefile.deps
 …
 Decod_LIBRARY                   =       -lDecod \
                                         $(Custom_LIBRARY)               \
+                                        $(Priority_LIBRARY)             \
                                         $(Behavioural_LIBRARY)
 Decod_DIR_LIBRARY               =       -L$(Decod_DIR)/lib      \
+Decod_DIR_LIBRARY               =       -L$(Decod_DIR)/lib              \
                                         $(Custom_DIR_LIBRARY)           \
+                                        $(Priority_DIR_LIBRARY)         \
                                         $(Behavioural_DIR_LIBRARY)
 …
                                 @\
                                 $(MAKE) Behavioural_library;            \
+                                $(MAKE) Priority_library;               \
                                 $(MAKE) Custom_library;                 \
                                 $(MAKE) --directory=$(Decod_DIR) --makefile=Makefile;
 …
                                 @\
                                 $(MAKE) Behavioural_library_clean;      \
+                                $(MAKE) Priority_library_clean;         \
                                 $(MAKE) Custom_library_clean;           \
                                 $(MAKE) --directory=$(Decod_DIR) --makefile=Makefile clean;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/Makefile

r81	r88
24	24	library_clean : Decod_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/config_min.cfg

-              r87
+              r88
 Decod
        1       *4      # nb_context
        1       *4      # nb_inst_fetch        [0] [nb_context]
+       1       *4      # nb_inst_fetch                 [0] [nb_context]
        1       *4      # nb_inst_decod
+       1       *2      # nb_branch_speculated
+       0       +1      # size_branch_update_prediction
+       1       *2      # nb_branch_speculated          [0] [nb_context]
        1       *2      # nb_context_select
       32      *2      # size_general_data

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/config_mono_context.cfg

-              r87
+              r88
 Decod
        1       *4      # nb_context
+       16      *4      # nb_inst_fetch        [0] [nb_context]
+       4       *4      # nb_inst_decod
+       1       *2      # nb_branch_speculated
+       2       +1      # size_branch_update_prediction
+       16      *4      # nb_inst_fetch                 [0] [nb_context]
+       4       *4      # nb_inst_decod
+       1       *2      # nb_branch_speculated          [0] [nb_context]
        1       *2      # nb_context_select
       32      *2      # size_general_data

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/config_multi_context.cfg

-              r87
+              r88
 Decod
        4       *4      # nb_context
        1       *4      # nb_inst_fetch        [0] [nb_context]
        2       *4      # nb_inst_fetch        [1] [nb_context]
        4       *4      # nb_inst_fetch        [2] [nb_context]
        8       *4      # nb_inst_fetch        [3] [nb_context]
+       1       *4      # nb_inst_fetch                 [0] [nb_context]
+       2       *4      # nb_inst_fetch                 [1] [nb_context]
+       4       *4      # nb_inst_fetch                 [2] [nb_context]
+       8       *4      # nb_inst_fetch                 [3] [nb_context]
        8       *2      # nb_inst_decod
+       1       *2      # nb_branch_speculated
+       2       *2      # size_branch_update_prediction
+       1       *2      # nb_branch_speculated          [0] [nb_context]
+       0       *2      # nb_branch_speculated          [1] [nb_context]
+       1       *2      # nb_branch_speculated          [2] [nb_context]
+       2       *2      # nb_branch_speculated          [3] [nb_context]
        4       *2      # nb_context_select
       32      *2      # size_general_data

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/include/Decod_request.h

-              r87
+              r88
   public : Ttype_t             _type                       ;
   public : Toperation_t        _operation                  ;
+  public : Tcontrol_t          _no_execute                 ;
   public : Tcontrol_t          _is_delay_slot              ;
   public : Tcontrol_t          _has_immediat               ;
 …
   public : Tspecial_address_t  _num_reg_re                 ;
   public : Texception_t        _exception_use              ;
+  public : Texception_t        _exception_ifetch           ;
+  public : Texception_t        _exception_decod            ;
   public : Tevent_type_t       _context_event_type         ;
 …
                     Ttype_t             type                       ,
                     Toperation_t        operation                  ,
+//                  Tcontrol_t          no_execute                 ,
                     Tcontrol_t          is_delay_slot              ,
                     Tcontrol_t          has_immediat               ,
 …
                     Tspecial_address_t  num_reg_re                 ,
                     Texception_t        exception_use              ,
+//                     Texception_t        exception_ifetch           ,
+//                     Texception_t        exception_decod            ,
                     Tevent_type_t       context_event_type         )
+    {
 …
       _exception_use               = exception_use              ;
       _context_event_type          = context_event_type         ;
+      _no_execute                  = 0                          ;
+      _exception_ifetch            = EXCEPTION_IFETCH_NONE      ;
+      _exception_decod             = EXCEPTION_DECOD_NONE       ;
+    }
   };
 …
 xe3caa309,x,y,z,
     BRANCH_STATE_NONE,0,BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK,0, 0x0,
 ,TYPE_MUL_DIV,OPERATION_MUL_DIV_L_DIV,false,
+,TYPE_DIV,OPERATION_DIV_L_DIV,false,
 ,0x0,1,10,1,20,0,0                 ,1,30,1,SPR_LOGIC_SR_CY_OV,
     EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
 …
 xe3caa30a,x,y,z,
     BRANCH_STATE_NONE,0,BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK,0, 0x0,
 ,TYPE_MUL_DIV,OPERATION_MUL_DIV_L_DIVU,true,
+,TYPE_DIV,OPERATION_DIV_L_DIVU,true,
 ,0x0,1,10,1,20,0,0                 ,1,30,1,SPR_LOGIC_SR_CY_OV,
     EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
 …
 xe3caa306,x,y,z,
 ,0,0,0,0,0,
     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MUL,false,
+    TYPE_MUL,OPERATION_MUL_L_MUL,false,
 ,0, 1,10, 1,20, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
     EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
 …
 xb3ca03fa,x,y,z,
 ,0,0,0,0,0,
     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MUL,false,
+    TYPE_MUL,OPERATION_MUL_L_MUL,false,
 ,0x3fa, 1,10, 0,0, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
     EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
 …
 xb3cafc06,x,y,z,
 ,0,0,0,0,0,
     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MUL,false,
+    TYPE_MUL,OPERATION_MUL_L_MUL,false,
 ,0xfffffc06, 1,10, 0,0, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
     EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
 …
 xe3caa30b,x,y,z,
 ,0,0,0,0,0,
     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MULU,false,
+    TYPE_MUL,OPERATION_MUL_L_MULU,false,
 ,0, 1,10, 1,20, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
     EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/src/main.cpp

-              r87
+              r88
 #include "Behavioural/Custom/include/Custom_example.h"
 #define NB_PARAMS 8
+#define NB_PARAMS 6
 void usage (int argc, char * argv[])
 …
   err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
   err (_("list_params is :\n"));
+  err (_(" * nb_context                                (uint32_t         )\n"));
+  err (_(" * nb_inst_fetch                [nb_context] (uint32_t         )\n"));
+  err (_(" * nb_inst_decod                             (uint32_t         )\n"));
+  err (_(" * nb_branch_speculated                      (uint32_t         )\n"));
+  err (_(" * size_branch_update_prediction             (uint32_t         )\n"));
+  err (_(" * nb_context_select                         (uint32_t         )\n"));
+  err (_(" * size_general_data                         (uint32_t         )\n"));
+  err (_(" * priority                                  (Tpriority_t      )\n"));
+  err (_(" * load_balancing                            (Tload_balancing_t)\n"));
+  err (_(" * nb_context                                 (uint32_t         )\n"));
+  err (_(" * nb_inst_fetch                 [nb_context] (uint32_t         )\n"));
+  err (_(" * nb_inst_decod                              (uint32_t         )\n"));
+  err (_(" * nb_branch_speculated          [nb_context] (uint32_t         )\n"));
+  err (_(" * nb_context_select                          (uint32_t         )\n"));
+  err (_(" * size_general_data                          (uint32_t         )\n"));
+  err (_(" * priority                                   (Tpriority_t      )\n"));
+  err (_(" * load_balancing                             (Tload_balancing_t)\n"));
   exit (1);
 …
   uint32_t            _nb_context           = fromString<uint32_t         >(argv[x++]);
   if (argc != static_cast<int>(2+NB_PARAMS+_nb_context))
+  if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context))
     usage (argc, argv);
   uint32_t          * _nb_inst_fetch        = new uint32_t [_nb_context];
+  uint32_t          * _nb_inst_fetch                = new uint32_t [_nb_context];
   for (uint32_t i=0;i<_nb_context; i++)
     _nb_inst_fetch [i] = fromString<uint32_t>(argv[x++]);
   uint32_t            _nb_inst_decod                = fromString<uint32_t         >(argv[x++]);
+  uint32_t            _nb_branch_speculated         = fromString<uint32_t         >(argv[x++]);
+  uint32_t            _size_branch_update_prediction= fromString<uint32_t         >(argv[x++]);
+  uint32_t          * _nb_branch_speculated         = new uint32_t [_nb_context];
+  for (uint32_t i=0;i<_nb_context; i++)
+    _nb_branch_speculated [i] = fromString<uint32_t>(argv[x++]);
+//   uint32_t          * _size_branch_update_prediction= new uint32_t [_nb_context];
+//   for (uint32_t i=0;i<_nb_context; i++)
+//     _size_branch_update_prediction[i] = fromString<uint32_t>(argv[x++]);
   uint32_t            _nb_context_select            = fromString<uint32_t         >(argv[x++]);
   uint32_t            _size_general_data            = fromString<uint32_t         >(argv[x++]);
 …
       for (uint32_t j=0; j<NB_INSTRUCTION; j++)
         _instruction_implemeted [i][j] = true;
+        _instruction_implemeted [i][j] = true;
+    }
 …
+    {
       morpheo::behavioural::core::multi_front_end::front_end::decod_unit::decod::Parameters * param = new morpheo::behavioural::core::multi_front_end::front_end::decod_unit::decod::Parameters
+        (_nb_context                   ,
+         _nb_inst_fetch                ,
+         _nb_inst_decod                ,
+         _nb_branch_speculated         ,
+         _size_branch_update_prediction,
+         _nb_context_select            ,
+         _size_general_data            ,
+         _priority                     ,
+         _load_balancing               ,
+         _instruction_implemeted       ,
+         &(morpheo::behavioural::custom::example_get_custom_information)
+         );
+        (_nb_context                   ,
+         _nb_inst_fetch                ,
+         _nb_inst_decod                ,
+         _nb_branch_speculated         ,
+//          _size_branch_update_prediction,
+         _nb_context_select            ,
+         _size_general_data            ,
+         _priority                     ,
+         _load_balancing               ,
+         _instruction_implemeted       ,
+         &(morpheo::behavioural::custom::example_get_custom_information),
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());
 …
   delete _nb_inst_fetch;
   delete _instruction_implemeted;
+  delete _nb_branch_speculated;
+//   delete _size_branch_update_prediction;
   return (_return);
+}

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/src/test.cpp

-              r87
+              r88
 #ifdef STATISTICS
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
+  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,0);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Decod * _Decod = new Decod
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
   ALLOC2_SC_SIGNAL( in_IFETCH_VAL                         ," in_IFETCH_VAL                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL(out_IFETCH_ACK                         ,"out_IFETCH_ACK                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ," in_IFETCH_INSTRUCTION                 ",Tinstruction_t     ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_IFETCH_VAL                         ," in_IFETCH_VAL                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
+  ALLOC2_SC_SIGNAL(out_IFETCH_ACK                         ,"out_IFETCH_ACK                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
+  ALLOC2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ," in_IFETCH_INSTRUCTION                 ",Tinstruction_t     ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
   ALLOC1_SC_SIGNAL( in_IFETCH_CONTEXT_ID                  ," in_IFETCH_CONTEXT_ID                  ",Tcontext_t         ,_param->_nb_context);
   ALLOC1_SC_SIGNAL( in_IFETCH_ADDRESS                     ," in_IFETCH_ADDRESS                     ",Tgeneral_address_t ,_param->_nb_context);
 …
   ALLOC1_SC_SIGNAL( in_IFETCH_BRANCH_STATE                ," in_IFETCH_BRANCH_STATE                ",Tbranch_state_t    ,_param->_nb_context);
   ALLOC1_SC_SIGNAL( in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ," in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ",Tprediction_ptr_t  ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_IFETCH_EXCEPTION                   ," in_IFETCH_EXCEPTION                   ",Texception_t       ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_DECOD_VAL                          ,"out_DECOD_VAL                          ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DECOD_ACK                          ," in_DECOD_ACK                          ",Tcontrol_t         ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_TYPE                         ,"out_DECOD_TYPE                         ",Ttype_t            ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OPERATION                    ,"out_DECOD_OPERATION                    ",Toperation_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_NO_EXECUTE                   ,"out_DECOD_NO_EXECUTE                   ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_IS_DELAY_SLOT                ,"out_DECOD_IS_DELAY_SLOT                ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_ADDRESS                      ,"out_DECOD_ADDRESS                      ",Tgeneral_data_t    ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_NUM_REG_RE                   ,"out_DECOD_NUM_REG_RE                   ",Tspecial_address_t ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_EXCEPTION_USE                ,"out_DECOD_EXCEPTION_USE                ",Texception_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_EXCEPTION                    ,"out_DECOD_EXCEPTION                    ",Texception_t       ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_PREDICT_VAL                        ,"out_PREDICT_VAL                        ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_PREDICT_ACK                        ," in_PREDICT_ACK                        ",Tcontrol_t         ,_param->_nb_inst_decod);
 …
   ALLOC_SC_SIGNAL ( in_CONTEXT_EVENT_ACK                  ," in_CONTEXT_EVENT_ACK                  ",Tcontrol_t         );
   ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_CONTEXT_ID           ,"out_CONTEXT_EVENT_CONTEXT_ID           ",Tcontext_t         );
+  ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_DEPTH                ,"out_CONTEXT_EVENT_DEPTH                ",Tdepth_t           );
   ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_TYPE                 ,"out_CONTEXT_EVENT_TYPE                 ",Tevent_type_t      );
   ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_IS_DELAY_SLOT        ,"out_CONTEXT_EVENT_IS_DELAY_SLOT        ",Tcontrol_t         );
 …
   (*(_Decod->in_NRESET))       (*(in_NRESET));
   INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_VAL                         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Decod,out_IFETCH_ACK                         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_INSTRUCTION                 ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_VAL                         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
+  INSTANCE2_SC_SIGNAL(_Decod,out_IFETCH_ACK                         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
+  INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_INSTRUCTION                 ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_CONTEXT_ID                  ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_ADDRESS                     ,_param->_nb_context);
 //   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_ADDRESS_NEXT                ,_param->_nb_context);
-  if (_param->_have_port_inst_ifetch_ptr)
-  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_INST_IFETCH_PTR             ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_BRANCH_STATE                ,_param->_nb_context);
+  if (_param->_have_port_branch_update_prediction_id)
+  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_EXCEPTION                   ,_param->_nb_context);
+  for (uint32_t i=0; i<_param->_nb_context; i++)
+    {
+      if (_param->_have_port_inst_ifetch_ptr)
+        INSTANCE_SC_SIGNAL(_Decod, in_IFETCH_INST_IFETCH_PTR [i]);
+//       if (_param->_have_port_branch_update_prediction_id)
+      if (_param->_have_port_depth)
+        INSTANCE_SC_SIGNAL(_Decod, in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [i]);
+    }
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_VAL                          ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod, in_DECOD_ACK                          ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_TYPE                         ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_OPERATION                    ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_NO_EXECUTE                   ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_IS_DELAY_SLOT                ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_ADDRESS                      ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_NUM_REG_RE                   ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_EXCEPTION_USE                ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_EXCEPTION                    ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_VAL                        ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod, in_PREDICT_ACK                        ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod);
+  if (_param->_have_port_branch_update_prediction_id)
+//   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod);
 …
 //   INSTANCE1_SC_SIGNAL(_Decod, in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod, in_CONTEXT_DECOD_ENABLE               ,_param->_nb_context);
+  if (_param->_have_port_depth)
+  INSTANCE1_SC_SIGNAL(_Decod, in_CONTEXT_DEPTH                      ,_param->_nb_context);
+  for (uint32_t i=0; i<_param->_nb_context; i++)
+    if (_param->_have_port_depth)
+      INSTANCE_SC_SIGNAL(_Decod, in_CONTEXT_DEPTH [i]);
   INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_VAL                  );
   INSTANCE_SC_SIGNAL (_Decod, in_CONTEXT_EVENT_ACK                  );
   if (_param->_have_port_context_id)
   INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_CONTEXT_ID           );
+  if (_param->_have_port_depth)
+  INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_DEPTH                );
   INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_TYPE                 );
   INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_IS_DELAY_SLOT        );
 …
                       if (_param->_have_port_inst_ifetch_ptr)
                       in_IFETCH_INST_IFETCH_PTR [i]->write(0);
+                      in_IFETCH_EXCEPTION       [i]->write(EXCEPTION_IFETCH_NONE);
                       // Alignement
 …
                     TEST(Tcontrol_t         , out_PREDICT_MATCH_INST_IFETCH_PTR       [i]->read(),((request [context].front()._address)%_param->_nb_inst_fetch[context]) == 0);
                     TEST(Tbranch_state_t    , out_PREDICT_BRANCH_STATE                [i]->read(), request [context].front()._branch_state               );
+                    if (_param->_have_port_branch_update_prediction_id)
+//                  if (_param->_have_port_branch_update_prediction_id)
+                    if (_param->_have_port_depth)
                     TEST(Tprediction_ptr_t  , out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i]->read(), request [context].front()._branch_update_prediction_id);
                     TEST(Tbranch_condition_t, out_PREDICT_BRANCH_CONDITION            [i]->read(), request [context].front()._branch_condition           );
 …
                     if (_param->_have_port_context_id)
                     TEST(Tcontext_t     ,out_CONTEXT_EVENT_CONTEXT_ID   ->read(), context);
+                    if (_param->_have_port_depth )
+                    TEST(Tcontext_t     ,out_CONTEXT_EVENT_DEPTH        ->read(), request [context].front()._depth        );
                     TEST(Tevent_type_t  ,out_CONTEXT_EVENT_TYPE         ->read(), request [context].front()._context_event_type);
                     TEST(Tcontrol_t     ,out_CONTEXT_EVENT_IS_DELAY_SLOT->read(), request [context].front()._is_delay_slot);
 …
   delete []  in_IFETCH_BRANCH_STATE                ;
   delete []  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;
+  delete []  in_IFETCH_EXCEPTION                   ;
   delete [] out_DECOD_VAL                          ;
 …
   delete [] out_DECOD_TYPE                         ;
   delete [] out_DECOD_OPERATION                    ;
+  delete [] out_DECOD_NO_EXECUTE                   ;
   delete [] out_DECOD_IS_DELAY_SLOT                ;
   delete [] out_DECOD_ADDRESS                      ;
 …
   delete [] out_DECOD_NUM_REG_RE                   ;
   delete [] out_DECOD_EXCEPTION_USE                ;
+  delete [] out_DECOD_EXCEPTION                    ;
   delete [] out_PREDICT_VAL                        ;
 …
   delete     in_CONTEXT_EVENT_ACK                  ;
   delete    out_CONTEXT_EVENT_CONTEXT_ID           ;
+  delete    out_CONTEXT_EVENT_DEPTH                ;
   delete    out_CONTEXT_EVENT_TYPE                 ;
   delete    out_CONTEXT_EVENT_IS_DELAY_SLOT        ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Decod.h

-              r86
+              r88
 #endif
-#include <iostream>
-#include <list>
 #include "Common/include/ToString.h"
 #include "Common/include/Debug.h"
 …
 #endif
 #include "Behavioural/include/Usage.h"
+#include "Behavioural/Generic/Priority/include/Priority.h"
+#include <iostream>
+#include <list>
 namespace morpheo {
 …
   public    : SC_IN (Tbranch_state_t    )  **  in_IFETCH_BRANCH_STATE                ;//[nb_context]
   public    : SC_IN (Tprediction_ptr_t  )  **  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;//[nb_context]
+  public    : SC_IN (Texception_t       )  **  in_IFETCH_EXCEPTION                   ;//[nb_context]
     // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_VAL                          ;//[nb_inst_decod]
 …
   public    : SC_OUT(Ttype_t            )  ** out_DECOD_TYPE                         ;//[nb_inst_decod]
   public    : SC_OUT(Toperation_t       )  ** out_DECOD_OPERATION                    ;//[nb_inst_decod]
+  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_NO_EXECUTE                   ;//[nb_inst_decod]
   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_IS_DELAY_SLOT                ;//[nb_inst_decod]
   public    : SC_OUT(Tgeneral_data_t    )  ** out_DECOD_ADDRESS                      ;//[nb_inst_decod]
 …
   public    : SC_OUT(Tspecial_address_t )  ** out_DECOD_NUM_REG_RE                   ;//[nb_inst_decod]
   public    : SC_OUT(Texception_t       )  ** out_DECOD_EXCEPTION_USE                ;//[nb_inst_decod]
+  public    : SC_OUT(Texception_t       )  ** out_DECOD_EXCEPTION                    ;//[nb_inst_decod]
     // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_IN (Tcontrol_t         )   *  in_CONTEXT_EVENT_ACK                  ;
   public    : SC_OUT(Tcontext_t         )   * out_CONTEXT_EVENT_CONTEXT_ID           ;
+  public    : SC_OUT(Tdepth_t           )   * out_CONTEXT_EVENT_DEPTH                ;
   public    : SC_OUT(Tevent_type_t      )   * out_CONTEXT_EVENT_TYPE                 ;
   public    : SC_OUT(Tcontrol_t         )   * out_CONTEXT_EVENT_IS_DELAY_SLOT        ;
 …
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  private   : generic::priority::Priority   * _priority;
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  private   : uint32_t                        reg_CONTEXT_PRIORITY;
   private   : Tgeneral_data_t               * reg_CONTEXT_ADDRESS_PREVIOUS     ; //[nb_context]
   private   : Tcontrol_t                    * reg_CONTEXT_IS_DELAY_SLOT        ; //[nb_context]
 …
   private   : Tcontrol_t                    * internal_CONTEXT_IS_DELAY_SLOT   ; //[nb_context]
+  private   : Tcontrol_t                    * internal_DECOD_VAL               ; //[nb_inst_decod]
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   private   : decod_instruction_t           * _decod_instruction;
 …
   private   : function_decod_t           **** _function_decod   ; //[nb_context][type][opcod]
   private   : function_decod_t           **** _function_custom  ; //[nb_context][type][opcod]
-  private   : std::list<select_t>             select;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Parameters.h

-              r86
+              r88
   public : uint32_t          * _nb_inst_fetch                ; //[nb_context]
   public : uint32_t            _nb_inst_decod                ;
   public : uint32_t            _size_general_data            ;
   public : uint32_t            _nb_branch_speculated         ;
+  public : uint32_t            _size_branch_update_prediction;
+//public : uint32_t            _size_general_data            ;
+  public : uint32_t          * _nb_branch_speculated         ; //[nb_context]
+//public : uint32_t          * _size_branch_update_prediction; //[nb_context]
   public : uint32_t            _nb_context_select            ;
   public : Tpriority_t         _priority                     ;
   public : Tload_balancing_t   _load_balancing               ;
   public : bool             ** _instruction_implemeted       ; //[nb_context][nb_instruction]
   public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (uint32_t);
+  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void);
+  public : uint32_t            _max_nb_inst_fetch     ;
+  public : uint32_t            _size_address_inst     ;
+  public : uint32_t            _size_context_id       ;
+  public : uint32_t            _size_depth            ;
+  public : uint32_t            _size_inst_ifetch_ptr  ;
+  public : bool                _have_port_context_id                 ;
+  public : bool                _have_port_depth                      ;
+  public : bool                _have_port_branch_update_prediction_id;
+  public : bool                _have_port_inst_ifetch_ptr            ;
+  public : uint32_t            _max_nb_inst_fetch;
+//public : uint32_t            _size_address_inst;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t          * nb_inst_fetch                ,
                         uint32_t            nb_inst_decod                ,
+                        uint32_t          * nb_branch_speculated         ,
+//                      uint32_t          * size_branch_update_prediction,
+                        uint32_t            nb_context_select            ,
                         uint32_t            size_general_data            ,
-                        uint32_t            nb_branch_speculated         ,
-                        uint32_t            size_branch_update_prediction,
-                        uint32_t            nb_context_select            ,
                         Tpriority_t         priority                     ,
                         Tload_balancing_t   load_balancing               ,
                         bool             ** instruction_implemeted       ,
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t));
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                        bool                is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Types.h

-              r81
+              r88
 namespace decod {
-  class select_t
+  {
-  public : uint32_t _context ;
-  public : uint32_t _inst_fetch;
-  public : select_t (uint32_t context,
-                     uint32_t inst_fetch)
+    {
-      _context    = context ;
-      _inst_fetch = inst_fetch;
+    }
-  };
 }; // end namespace decod

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod.cpp

-              r81
+              r88
     log_printf(FUNC,Decod,FUNCTION,"Begin");
+#if DEBUG_Decod == true
+    log_printf(INFO,Decod,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Decod,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Decod,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Decod,FUNCTION,"Method - transition");
 …
             if (_param->_have_port_context_id)
             sensitive << (*(in_IFETCH_CONTEXT_ID                  [i]));
             if (_param->_have_port_branch_update_prediction_id)
+            if (_param->_have_port_depth)
             sensitive << (*(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [i]));
             if (_param->_have_port_depth)
 …
 # ifdef SYSTEMCASS_SPECIFIC
+        /*
         // List dependency information
 …
+              }
+            if (_param->_have_port_depth)
+              {
+            for (uint32_t x=0; x<_param->_nb_context; x++)
+              {
+            for (uint32_t x=0; x<_param->_nb_context; x++)
+              {
+            if (_param->_have_port_depth[i])
+              {
                 (*(out_DECOD_DEPTH [i])) (*(in_CONTEXT_DECOD_ENABLE [x]));
                 (*(out_DECOD_DEPTH [i])) (*(in_CONTEXT_DEPTH        [x]));
 …
                 if (_param->_have_port_context_id)
                 (*(out_PREDICT_MATCH_INST_IFETCH_PTR [i])) (*(in_IFETCH_CONTEXT_ID      [x]));
                 if (_param->_have_port_inst_ifetch_ptr)
+                if (_param->_have_port_inst_ifetch_ptr[i])
                 (*(out_PREDICT_MATCH_INST_IFETCH_PTR [i])) (*(in_IFETCH_INST_IFETCH_PTR [x]));
                 for (uint32_t y=0; y<_param->_nb_inst_fetch [x]; y++)
 …
+              }
+          }
+        */
 # endif
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_allocation.cpp

-              r86
+              r88
 /*
  * $Id$
+ * $id: Decod_allocation.cpp 86 2008-05-14 17:08:56Z rosiere $
+ *
  * [ Description ]
 …
     // ~~~~~[ Interface : "ifetch" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC2_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context, _param->_nb_inst_fetch[alloc_interface_it1]);
+      ALLOC2_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context, _param->_nb_inst_fetch[it1]);
       _ALLOC2_VALACK_IN ( in_IFETCH_VAL        ,VAL, _param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
       _ALLOC2_VALACK_OUT(out_IFETCH_ACK        ,ACK, _param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
       _ALLOC2_SIGNAL_IN ( in_IFETCH_INSTRUCTION,"instruction", Tinstruction_t, _param->_size_instruction,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
+      _ALLOC2_VALACK_IN ( in_IFETCH_VAL        ,VAL, _param->_nb_context, _param->_nb_inst_fetch[it1]);
+      _ALLOC2_VALACK_OUT(out_IFETCH_ACK        ,ACK, _param->_nb_context, _param->_nb_inst_fetch[it1]);
+      _ALLOC2_SIGNAL_IN ( in_IFETCH_INSTRUCTION,"instruction", Tinstruction_t, _param->_size_instruction,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+    }
+    {
       ALLOC1_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context);
+      ALLOC1_SIGNAL_IN (in_IFETCH_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id              );
+      ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS                    ,"address"                    ,Tgeneral_address_t ,_param->_size_address_inst            );
+//    ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS_NEXT               ,"address_next"               ,Tgeneral_address_t ,_param->_size_address_inst            );
+      ALLOC1_SIGNAL_IN (in_IFETCH_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr         );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
+      ALLOC1_SIGNAL_IN (in_IFETCH_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      );
+      ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS                    ,"address"                    ,Tgeneral_address_t ,_param->_size_instruction_address    );
+//    ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS_NEXT               ,"address_next"               ,Tgeneral_address_t ,_param->_size_instruction_address    );
+      ALLOC1_SIGNAL_IN (in_IFETCH_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           );
+      ALLOC1_SIGNAL_IN (in_IFETCH_EXCEPTION                  ,"exception"                  ,Texception_t       ,_param->_size_exception_ifetch);
+    }
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type                  );
       ALLOC1_SIGNAL_OUT(out_DECOD_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation             );
+      ALLOC1_SIGNAL_OUT(out_DECOD_NO_EXECUTE   ,"no_execute"   ,Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_address_inst          );
+      ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_instruction_address          );
       ALLOC1_SIGNAL_OUT(out_DECOD_HAS_IMMEDIAT ,"has_immediat" ,Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_IMMEDIAT     ,"immediat"     ,Tgeneral_data_t   ,_param->_size_general_data          );
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register_logic);
       ALLOC1_SIGNAL_OUT(out_DECOD_EXCEPTION_USE,"exception_use",Texception_t      ,_param->_size_exception_use         );
+      ALLOC1_SIGNAL_OUT(out_DECOD_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception_decod       );
+    }
 …
       ALLOC1_VALACK_OUT(out_PREDICT_VAL                        ,VAL);
       ALLOC1_VALACK_IN ( in_PREDICT_ACK                        ,ACK);
       ALLOC1_SIGNAL_OUT(out_PREDICT_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id              );
       ALLOC1_SIGNAL_OUT(out_PREDICT_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                                     );
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition        );
 //    ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STACK_WRITE         ,"branch_stack_write"         ,Tcontrol_t         ,1                                     );
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                                     );
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC                ,"address_src"                ,Tgeneral_data_t    ,_param->_size_address_inst            );
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST               ,"address_dest"               ,Tgeneral_data_t    ,_param->_size_address_inst            );
 //    ALLOC1_SIGNAL_IN ( in_PREDICT_CAN_CONTINUE               ,"can_continue"               ,Tcontrol_t         ,1                                     );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition);
+//    ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STACK_WRITE         ,"branch_stack_write"         ,Tcontrol_t         ,1                             );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC                ,"address_src"                ,Tgeneral_data_t    ,_param->_size_instruction_address    );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST               ,"address_dest"               ,Tgeneral_data_t    ,_param->_size_instruction_address    );
+//    ALLOC1_SIGNAL_IN ( in_PREDICT_CAN_CONTINUE               ,"can_continue"               ,Tcontrol_t         ,1                             );
+    }
 …
       ALLOC_VALACK_IN ( in_CONTEXT_EVENT_ACK          ,ACK);
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id  );
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_DEPTH        ,"depth"        ,Tdepth_t       ,_param->_size_depth       );
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_TYPE         ,"type"         ,Tevent_type_t  ,_param->_size_event_type  );
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t     ,1                         );
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_address_inst);
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS_EPCR ,"address_epcr" ,Tgeneral_data_t,_param->_size_address_inst);
+    }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS_EPCR ,"address_epcr" ,Tgeneral_data_t,_param->_size_instruction_address);
+    }
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     reg_CONTEXT_ADDRESS_PREVIOUS      = new Tgeneral_data_t [_param->_nb_context];
     reg_CONTEXT_IS_DELAY_SLOT         = new Tcontrol_t      [_param->_nb_context];
 …
     internal_CONTEXT_ADDRESS_PREVIOUS = new Tgeneral_data_t [_param->_nb_context];
     internal_CONTEXT_IS_DELAY_SLOT    = new Tcontrol_t      [_param->_nb_context];
+#ifdef STATISTICS
+    internal_DECOD_VAL                = new Tcontrol_t      [_param->_nb_inst_decod];
+#endif
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    _priority = new generic::priority::Priority (_name+"_priority"      ,
+                                                 _param->_priority      ,
+                                                 _param->_load_balancing,
+                                                 _param->_nb_context    ,
+                                                 _param->_nb_inst_fetch ,
+                                                 _param->_nb_context_select);
     const uint32_t nb_opcod_type = 14;
 …
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST4   ]) _function_decod [i][ 2][OPCOD_LV_CUST4   ] = &(instruction_lv_custom);
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST1    ]) _function_custom[i][ 0][OPCOD_L_CUST1    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_1   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST2    ]) _function_custom[i][ 0][OPCOD_L_CUST2    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_2   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST3    ]) _function_custom[i][ 0][OPCOD_L_CUST3    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_3   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST4    ]) _function_custom[i][ 0][OPCOD_L_CUST4    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_4   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST5    ]) _function_custom[i][ 0][OPCOD_L_CUST5    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_5   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST6    ]) _function_custom[i][ 0][OPCOD_L_CUST6    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_6   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST7    ]) _function_custom[i][ 0][OPCOD_L_CUST7    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_7   );
         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST8    ]) _function_custom[i][ 0][OPCOD_L_CUST8    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_8   );
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_D ]) _function_custom[i][ 1][OPCOD_LF_CUST1_D ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LF_1_D);
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_S ]) _function_custom[i][ 1][OPCOD_LF_CUST1_S ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LF_1_S);
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST1   ]) _function_custom[i][ 2][OPCOD_LV_CUST1   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_1  );
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST2   ]) _function_custom[i][ 2][OPCOD_LV_CUST2   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_2  );
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST3   ]) _function_custom[i][ 2][OPCOD_LV_CUST3   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_3  );
 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST4   ]) _function_custom[i][ 2][OPCOD_LV_CUST4   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_4  );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST1    ]) _function_custom[i][ 0][OPCOD_L_CUST1    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_1   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST2    ]) _function_custom[i][ 0][OPCOD_L_CUST2    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_2   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST3    ]) _function_custom[i][ 0][OPCOD_L_CUST3    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_3   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST4    ]) _function_custom[i][ 0][OPCOD_L_CUST4    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_4   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST5    ]) _function_custom[i][ 0][OPCOD_L_CUST5    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_5   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST6    ]) _function_custom[i][ 0][OPCOD_L_CUST6    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_6   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST7    ]) _function_custom[i][ 0][OPCOD_L_CUST7    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_7   );
+        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST8    ]) _function_custom[i][ 0][OPCOD_L_CUST8    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_8   );
+//      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_D ]) _function_custom[i][ 1][OPCOD_LF_CUST1_D ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LF_1_D);
+//      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_S ]) _function_custom[i][ 1][OPCOD_LF_CUST1_S ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LF_1_S);
+//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST1   ]) _function_custom[i][ 2][OPCOD_LV_CUST1   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_1  );
+//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST2   ]) _function_custom[i][ 2][OPCOD_LV_CUST2   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_2  );
+//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST3   ]) _function_custom[i][ 2][OPCOD_LV_CUST3   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_3  );
+//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST4   ]) _function_custom[i][ 2][OPCOD_LV_CUST4   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_4  );
+      }
 …
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_deallocation.cpp

-              r86
+              r88
 #include "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Decod.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
         delete    in_CLOCK ;
         delete    in_NRESET;
+        DELETE2_SIGNAL( in_IFETCH_VAL        , _param->_nb_context, _param->_nb_inst_fetch[it1],1);
+        DELETE2_SIGNAL(out_IFETCH_ACK        , _param->_nb_context, _param->_nb_inst_fetch[it1],1);
+        DELETE2_SIGNAL( in_IFETCH_INSTRUCTION, _param->_nb_context, _param->_nb_inst_fetch[it1],_param->_size_instruction);
+        DELETE1_SIGNAL(in_IFETCH_CONTEXT_ID                 , _param->_nb_context,_param->_size_context_id      );
+        DELETE1_SIGNAL(in_IFETCH_ADDRESS                    , _param->_nb_context,_param->_size_instruction_address    );
+//      DELETE1_SIGNAL(in_IFETCH_ADDRESS_NEXT               , _param->_nb_context,_param->_size_instruction_address    );
+        DELETE1_SIGNAL(in_IFETCH_INST_IFETCH_PTR            , _param->_nb_context,_param->_size_inst_ifetch_ptr );
+        DELETE1_SIGNAL(in_IFETCH_BRANCH_STATE               , _param->_nb_context,_param->_size_branch_state    );
+        DELETE1_SIGNAL(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID, _param->_nb_context,_param->_size_depth           );
+        DELETE1_SIGNAL(in_IFETCH_EXCEPTION                  , _param->_nb_context,_param->_size_exception_ifetch);
+        delete []  in_IFETCH_VAL                         ;
+        delete [] out_IFETCH_ACK                         ;
+        delete []  in_IFETCH_INSTRUCTION                 ;
+        if (_param->_have_port_context_id)
+        delete []  in_IFETCH_CONTEXT_ID                  ;
+        delete []  in_IFETCH_ADDRESS                     ;
+//      delete []  in_IFETCH_ADDRESS_NEXT                ;
+        if (_param->_have_port_inst_ifetch_ptr)
+        delete []  in_IFETCH_INST_IFETCH_PTR             ;
+        delete []  in_IFETCH_BRANCH_STATE                ;
+        if (_param->_have_port_branch_update_prediction_id)
+        delete []  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;
+        DELETE1_SIGNAL(out_DECOD_VAL          ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL( in_DECOD_ACK          ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL(out_DECOD_CONTEXT_ID   ,_param->_nb_inst_decod,_param->_size_context_id            );
+        DELETE1_SIGNAL(out_DECOD_DEPTH        ,_param->_nb_inst_decod,_param->_size_depth                 );
+        DELETE1_SIGNAL(out_DECOD_TYPE         ,_param->_nb_inst_decod,_param->_size_type                  );
+        DELETE1_SIGNAL(out_DECOD_OPERATION    ,_param->_nb_inst_decod,_param->_size_operation             );
+        DELETE1_SIGNAL(out_DECOD_NO_EXECUTE   ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_IS_DELAY_SLOT,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_ADDRESS      ,_param->_nb_inst_decod,_param->_size_instruction_address          );
+        DELETE1_SIGNAL(out_DECOD_HAS_IMMEDIAT ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_IMMEDIAT     ,_param->_nb_inst_decod,_param->_size_general_data          );
+        DELETE1_SIGNAL(out_DECOD_READ_RA      ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_NUM_REG_RA   ,_param->_nb_inst_decod,_param->_size_general_register_logic);
+        DELETE1_SIGNAL(out_DECOD_READ_RB      ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_NUM_REG_RB   ,_param->_nb_inst_decod,_param->_size_general_register_logic);
+        DELETE1_SIGNAL(out_DECOD_READ_RC      ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_NUM_REG_RC   ,_param->_nb_inst_decod,_param->_size_special_register_logic);
+        DELETE1_SIGNAL(out_DECOD_WRITE_RD     ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_NUM_REG_RD   ,_param->_nb_inst_decod,_param->_size_general_register_logic);
+        DELETE1_SIGNAL(out_DECOD_WRITE_RE     ,_param->_nb_inst_decod,1                                   );
+        DELETE1_SIGNAL(out_DECOD_NUM_REG_RE   ,_param->_nb_inst_decod,_param->_size_special_register_logic);
+        DELETE1_SIGNAL(out_DECOD_EXCEPTION_USE,_param->_nb_inst_decod,_param->_size_exception_use         );
+        DELETE1_SIGNAL(out_DECOD_EXCEPTION    ,_param->_nb_inst_decod,_param->_size_exception_decod       );
+        delete [] out_DECOD_VAL                          ;
+        delete []  in_DECOD_ACK                          ;
+        if (_param->_have_port_context_id)
+        delete [] out_DECOD_CONTEXT_ID                   ;
+        if (_param->_have_port_depth)
+        delete [] out_DECOD_DEPTH                        ;
+        delete [] out_DECOD_TYPE                         ;
+        delete [] out_DECOD_OPERATION                    ;
+        delete [] out_DECOD_IS_DELAY_SLOT                ;
+        delete [] out_DECOD_ADDRESS                      ;
+        delete [] out_DECOD_HAS_IMMEDIAT                 ;
+        delete [] out_DECOD_IMMEDIAT                     ;
+        delete [] out_DECOD_READ_RA                      ;
+        delete [] out_DECOD_NUM_REG_RA                   ;
+        delete [] out_DECOD_READ_RB                      ;
+        delete [] out_DECOD_NUM_REG_RB                   ;
+        delete [] out_DECOD_READ_RC                      ;
+        delete [] out_DECOD_NUM_REG_RC                   ;
+        delete [] out_DECOD_WRITE_RD                     ;
+        delete [] out_DECOD_NUM_REG_RD                   ;
+        delete [] out_DECOD_WRITE_RE                     ;
+        delete [] out_DECOD_NUM_REG_RE                   ;
+        delete [] out_DECOD_EXCEPTION_USE                ;
+        DELETE1_SIGNAL(out_PREDICT_VAL                        ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL( in_PREDICT_ACK                        ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL(out_PREDICT_CONTEXT_ID                 ,_param->_nb_inst_decod,_param->_size_context_id      );
+        DELETE1_SIGNAL(out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod,_param->_size_branch_state    );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod,_param->_size_depth           );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod,_param->_size_branch_condition);
+//      DELETE1_SIGNAL(out_PREDICT_BRANCH_STACK_WRITE         ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_DIRECTION           ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL(out_PREDICT_ADDRESS_SRC                ,_param->_nb_inst_decod,_param->_size_instruction_address    );
+        DELETE1_SIGNAL(out_PREDICT_ADDRESS_DEST               ,_param->_nb_inst_decod,_param->_size_instruction_address    );
+//      DELETE1_SIGNAL( in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod,1                             );
+        delete [] out_PREDICT_VAL                        ;
+        delete []  in_PREDICT_ACK                        ;
+        if (_param->_have_port_context_id)
+        delete [] out_PREDICT_CONTEXT_ID                 ;
+        delete [] out_PREDICT_BRANCH_STATE               ;
+        delete [] out_PREDICT_MATCH_INST_IFETCH_PTR      ;
+        if (_param->_have_port_branch_update_prediction_id)
+        delete [] out_PREDICT_BRANCH_UPDATE_PREDICTION_ID;
+        delete [] out_PREDICT_BRANCH_CONDITION           ;
+//      delete [] out_PREDICT_BRANCH_STACK_WRITE         ;
+        delete [] out_PREDICT_BRANCH_DIRECTION           ;
+        delete [] out_PREDICT_ADDRESS_SRC                ;
+        delete [] out_PREDICT_ADDRESS_DEST               ;
+//      delete []  in_PREDICT_CAN_CONTINUE               ;
+        DELETE1_SIGNAL(in_CONTEXT_DECOD_ENABLE, _param->_nb_context,1);
+        DELETE1_SIGNAL(in_CONTEXT_DEPTH       , _param->_nb_context,_param->_size_depth);
+        delete []  in_CONTEXT_DECOD_ENABLE               ;
+        if (_param->_have_port_depth)
+        delete []  in_CONTEXT_DEPTH                      ;
+        DELETE_SIGNAL (out_CONTEXT_EVENT_VAL          ,1);
+        DELETE_SIGNAL ( in_CONTEXT_EVENT_ACK          ,1);
+        DELETE_SIGNAL (out_CONTEXT_EVENT_CONTEXT_ID   ,_param->_size_context_id  );
+        DELETE_SIGNAL (out_CONTEXT_EVENT_DEPTH        ,_param->_size_depth       );
+        DELETE_SIGNAL (out_CONTEXT_EVENT_TYPE         ,_param->_size_event_type  );
+        DELETE_SIGNAL (out_CONTEXT_EVENT_IS_DELAY_SLOT,1                         );
+        DELETE_SIGNAL (out_CONTEXT_EVENT_ADDRESS      ,_param->_size_instruction_address);
+        DELETE_SIGNAL (out_CONTEXT_EVENT_ADDRESS_EPCR ,_param->_size_instruction_address);
+        delete    out_CONTEXT_EVENT_VAL                  ;
+        delete     in_CONTEXT_EVENT_ACK                  ;
+        if (_param->_have_port_context_id)
+        delete    out_CONTEXT_EVENT_CONTEXT_ID           ;
+        delete    out_CONTEXT_EVENT_TYPE                 ;
+        delete    out_CONTEXT_EVENT_IS_DELAY_SLOT        ;
+        delete    out_CONTEXT_EVENT_ADDRESS              ;
+        delete    out_CONTEXT_EVENT_ADDRESS_EPCR         ;
+        delete    reg_CONTEXT_ADDRESS_PREVIOUS      ;
+        delete [] reg_CONTEXT_IS_DELAY_SLOT         ;
+        delete [] internal_CONTEXT_HAVE_TRANSACTION ;
+        delete [] internal_CONTEXT_ADDRESS_PREVIOUS ;
+        delete [] internal_CONTEXT_IS_DELAY_SLOT    ;
+#ifdef STATISTICS
+        delete [] internal_DECOD_VAL;
+#endif
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete    reg_CONTEXT_ADDRESS_PREVIOUS      ;
+    delete    reg_CONTEXT_IS_DELAY_SLOT         ;
+    delete    _priority;
-    delete    internal_CONTEXT_HAVE_TRANSACTION ;
-    delete    internal_CONTEXT_ADDRESS_PREVIOUS ;
-    delete    internal_CONTEXT_IS_DELAY_SLOT    ;
     const uint32_t nb_opcod_type = 14;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_genMealy.cpp

-              r87
+              r88
   void Decod::genMealy (void)
+  {
+    log_printf(TRACE,Decod,FUNCTION,"Begin");
+    log_begin(Decod,FUNCTION);
+    log_function(Decod,FUNCTION,_name.c_str());
     //-----------------------------------
 …
+      {
         decod_val   [i] = false;
+        predict_val [i] = false;
+      }
 …
     //-----------------------------------
     // scan all decod "slot_out"
     log_printf(TRACE,Decod,FUNCTION,"KANE LIVE");
     std::list<select_t>::iterator it=select.begin();
+    std::list<generic::priority::select_t> * select = _priority->select();
+    std::list<generic::priority::select_t>::iterator it=select->begin();
     for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+      {
         while ((it != select.end())     and  // have a no scanned "slot_in" ?
+        while ((it != select->end())    and  // have a no scanned "slot_in" ?
                (decod_val [i] == false) and  // have not a previous selected entry?
                (context_event_val == false)) // Have not a context_event (spr_access, exception, ...)
+          {
-            log_printf(TRACE,Decod,FUNCTION,"loop");
             predict_val [i] = false;
             Tcontext_t x = it->_context ;
             uint32_t   y = it->_inst_fetch;
+            Tcontext_t x = it->grp;
+            uint32_t   y = it->elt;
             // Test if this instruction is valid
 …
                 (can_continue [x]                == 1))    // context can decod instruction (have not a previous event)
+              {
+                can_continue      [x] = can_continue_next [x];
+                log_printf(TRACE,Decod,FUNCTION,"  * IFETCH [%d][%d]",x,y);
+                can_continue [x] = can_continue_next [x];
                 decod_val  [i]    = true;                        // fetch_val and decod_enable
 …
                 _decod_instruction->_is_delay_slot    = internal_CONTEXT_IS_DELAY_SLOT [x];
+                // Decod !
+                log_printf(TRACE,Decod,FUNCTION,"DECOD [%d]",i);
+                log_printf(TRACE,Decod,FUNCTION,"  * context       : %d",x);
+                log_printf(TRACE,Decod,FUNCTION,"  * fetch         : %d",y);
+                log_printf(TRACE,Decod,FUNCTION,"  * address       : %.8x",addr);
+                log_printf(TRACE,Decod,FUNCTION,"  * is_delay_slot : %d",internal_CONTEXT_IS_DELAY_SLOT [x]);
+                instruction_decod (_decod_instruction, _decod_param[x]);
+                Ttype_t type = _decod_instruction->_type;
+                // Test IFetch exception
+                Texception_t ifetch_exception = PORT_READ(in_IFETCH_EXCEPTION [x]);
+                if (ifetch_exception == EXCEPTION_IFETCH_NONE)
+                  {
+                    // Decod !
+                    log_printf(TRACE,Decod,FUNCTION,"  * DECOD [%d]",i);
+                    log_printf(TRACE,Decod,FUNCTION,"    * context       : %d",x);
+                    log_printf(TRACE,Decod,FUNCTION,"    * fetch         : %d",y);
+                    log_printf(TRACE,Decod,FUNCTION,"    * address       : %.8x (%.8x)",addr,(addr<<2));
+                    log_printf(TRACE,Decod,FUNCTION,"    * is_delay_slot : %d",internal_CONTEXT_IS_DELAY_SLOT [x]);
+                    instruction_decod (_decod_instruction, _decod_param[x]);
+                  }
+                else
+                  {
+                    // No decod : nop
+                    instruction_l_nop (_decod_instruction, _decod_param[x]);
+                    _decod_instruction->_exception_use = EXCEPTION_USE_NONE;
+                    _decod_instruction->_exception     = exception_ifetch_to_exception_decod(ifetch_exception);
+                    // INSTRUCTION_TLB
+                    // INSTRUCTION_PAGE
+                    // BUS_ERROR
+                    if (_decod_instruction->_is_delay_slot)
+                      _decod_instruction->_address_next       = _decod_instruction->_address_previous;
+                    else
+                      _decod_instruction->_address_next       = _decod_instruction->_address;
+                    _decod_instruction->_event_type         = EVENT_TYPE_EXCEPTION;
+                  }
+                Ttype_t  type  = _decod_instruction->_type;
+                Tdepth_t depth = (_param->_have_port_depth)?PORT_READ(in_CONTEXT_DEPTH [x]):0; // DEPTH_CURRENT
                 if (_param->_have_port_context_id)
                 PORT_WRITE(out_DECOD_CONTEXT_ID    [i], x);
                 if (_param->_have_port_depth)
                 PORT_WRITE(out_DECOD_DEPTH         [i], PORT_READ(in_CONTEXT_DEPTH [x]));
+                PORT_WRITE(out_DECOD_DEPTH         [i], depth);
                 PORT_WRITE(out_DECOD_TYPE          [i], type);
                 PORT_WRITE(out_DECOD_OPERATION     [i], _decod_instruction->_operation     );
+                PORT_WRITE(out_DECOD_NO_EXECUTE    [i], _decod_instruction->_no_execute    );
                 PORT_WRITE(out_DECOD_IS_DELAY_SLOT [i], _decod_instruction->_is_delay_slot );
                 PORT_WRITE(out_DECOD_ADDRESS       [i], addr);
 …
                 PORT_WRITE(out_DECOD_NUM_REG_RE    [i], _decod_instruction->_num_reg_re    );
                 PORT_WRITE(out_DECOD_EXCEPTION_USE [i], _decod_instruction->_exception_use );
+//              PORT_WRITE(out_DECOD_EXCEPTION     [i], _decod_instruction->_exception     );
                 if (type == TYPE_BRANCH)
+                  {
+                    log_printf(TRACE,Decod,FUNCTION,"  * type is branch");
+                    log_printf(TRACE,Decod,FUNCTION,"    * type is branch");
+                    log_printf(TRACE,Decod,FUNCTION,"      * address src  : %.8x (%.8x)",_decod_instruction->_address     ,_decod_instruction->_address     <<2);
+                    log_printf(TRACE,Decod,FUNCTION,"      * address dest : %.8x (%.8x)",_decod_instruction->_address_next,_decod_instruction->_address_next<<2);
                     predict_val [i]     = ifetch_ack  [x][y] // and decod_val [i]
 …
                     PORT_WRITE(out_PREDICT_MATCH_INST_IFETCH_PTR       [i],y == ((_param->_have_port_inst_ifetch_ptr)?PORT_READ(in_IFETCH_INST_IFETCH_PTR [x]):0));
                     PORT_WRITE(out_PREDICT_BRANCH_STATE                [i],PORT_READ(in_IFETCH_BRANCH_STATE                [x]));
                     if (_param->_have_port_branch_update_prediction_id)
                     PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i],PORT_READ(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [x]));
+                    if (_param->_have_port_depth)
+                    PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i],PORT_READ(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [x]));
                     PORT_WRITE(out_PREDICT_BRANCH_CONDITION            [i],_decod_instruction->_branch_condition  );
 //                  PORT_WRITE(out_PREDICT_BRANCH_STACK_WRITE          [i],_decod_instruction->_branch_stack_write);
 …
                     //can_continue_next [x] = PORT_READ(in_PREDICT_CAN_CONTINUE [i]); // can continue is set if direction is "not take" (also, continue is sequential order)
                     can_continue_next [x] = false; // one branch per context
+                    can_continue_next [x] = false; // one branch per context, the DS don't execute
+                  }
 …
                     if (_param->_have_port_context_id)
                     PORT_WRITE(out_CONTEXT_EVENT_CONTEXT_ID   , x);
+                    if (_param->_have_port_depth)
+                    PORT_WRITE(out_CONTEXT_EVENT_DEPTH        , depth);
                     PORT_WRITE(out_CONTEXT_EVENT_TYPE         , _decod_instruction->_event_type    );
                     PORT_WRITE(out_CONTEXT_EVENT_IS_DELAY_SLOT, _decod_instruction->_is_delay_slot );
 …
+              }
             log_printf(TRACE,Decod,FUNCTION,"  - num_(decod, context, fetch) : %d %d %d",i, x, y);
             log_printf(TRACE,Decod,FUNCTION,"    - ifetch_ack        : %d",ifetch_ack  [x][y]);
             log_printf(TRACE,Decod,FUNCTION,"    - context_event_val : %d",context_event_val );
             log_printf(TRACE,Decod,FUNCTION,"    - predict_val       : %d",predict_val [i]   );
             log_printf(TRACE,Decod,FUNCTION,"    - decod_val         : %d",decod_val   [i]   );
+            log_printf(TRACE,Decod,FUNCTION,"    - num_(decod, context, fetch) : %d %d %d",i, x, y);
+            log_printf(TRACE,Decod,FUNCTION,"      - ifetch_ack        : %d",ifetch_ack  [x][y]);
+            log_printf(TRACE,Decod,FUNCTION,"      - context_event_val : %d",context_event_val );
+            log_printf(TRACE,Decod,FUNCTION,"      - predict_val       : %d",predict_val [i]   );
+            log_printf(TRACE,Decod,FUNCTION,"      - decod_val         : %d",decod_val   [i]   );
             it ++;
 …
         PORT_WRITE(out_PREDICT_VAL [i], predict_val [i]);
         PORT_WRITE(out_DECOD_VAL   [i], decod_val   [i]);
+      }
+    log_printf(FUNC,Decod,FUNCTION,"End");
+#ifdef STATISTICS
+        internal_DECOD_VAL [i] = decod_val [i];
+#endif
+      }
+    log_end(Decod,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_statistics_allocation.cpp

-              r81
+              r88
                       "Decod",
                       param_statistics);
-    _stat_sum_inst_decod = _stat->create_variable ("sum_inst_decod" // ,"", "Sum of decod instruction"
-                                                   );
+    _stat_sum_inst_decod = _stat->create_variable("sum_inst_decod");
+    _stat->create_expr_average_by_cycle ("average_nb_inst_decod","sum_inst_decod","","Average of decod instruction by cycle");
+    _stat->create_expr_percent          ("percent_nb_inst_decod","average_nb_inst_decod", toString(_param->_nb_inst_decod), "Percent of decod instruction by cycle");
-    _stat->create_expr_average_by_cycle ("average_sum_inst_decod","sum_inst_decod","","Average of decod instruction by cycle");
-    _stat->create_expr_percent          ("percent_sum_inst_decod","average_sum_inst_decod", toString(_param->_nb_inst_decod), "Percent of decod instruction by cycle");
     log_printf(FUNC,Decod,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_transition.cpp

-              r87
+              r88
   void Decod::transition (void)
+  {
     log_printf(FUNC,Decod,FUNCTION,"Begin");
+    log_begin(Decod,FUNCTION);
     if (PORT_READ(in_NRESET) == 0)
+      {
         reg_CONTEXT_PRIORITY = 0;
+        _priority->reset();
         for (uint32_t i=0; i<_param->_nb_context; i++)
 …
     else
+      {
+        switch (_param->_priority)
+          {
+//        case PRIORITY_STATIC :
+//          {
+//            reg_CONTEXT_PRIORITY = (reg_CONTEXT_PRIORITY+_param->_nb_context_select)%_param->_nb_context;
+//            break;
+//          }
+          case PRIORITY_ROUND_ROBIN :
+            {
+              reg_CONTEXT_PRIORITY = (reg_CONTEXT_PRIORITY+1                         )%_param->_nb_context;
+              break;
+            }
+          default:
+            {
+              break;
+            }
+          }
+        // flush list
+        select.clear();
+        // Compute next scan order !!!
+        switch (_param->_load_balancing)
+          {
+//        case LOAD_BALANCING_BALANCE :
+//          {
+//            for (uint32_t j=0; j<_param->_max_nb_inst_fetch; j++)
+//              for (uint32_t i=0; i<_param->_nb_context_select; i++)
+//                {
+//                  uint32_t x=(reg_CONTEXT_PRIORITY+i)%_param->_nb_context;
+//                  // Test valid inst_fetch
+//                  if (j < _param->_nb_inst_fetch[x])
+//                    select.push_back(select_t(x,j));
+//                }
+//            break;
+//          }
+          case LOAD_BALANCING_MAXIMUM_FOR_PRIORITY :
+            {
+              for (uint32_t i=0; i<_param->_nb_context_select; i++)
+                {
+                  uint32_t x=(reg_CONTEXT_PRIORITY+i)%_param->_nb_context;
+                  for (uint32_t j=0; j<_param->_nb_inst_fetch[x]; j++)
+                    select.push_back(select_t(x,j));
+                }
+              break;
+            }
+          default :
+            {
+              break;
+            }
+          }
+        _priority->transition();
         // Compute "next previous" address
 …
           if (internal_CONTEXT_HAVE_TRANSACTION[i])
+            {
-#ifdef STATISTICS
-              (*_stat_sum_inst_decod) ++;
-#endif
               reg_CONTEXT_ADDRESS_PREVIOUS [i] = internal_CONTEXT_ADDRESS_PREVIOUS [i];
               reg_CONTEXT_IS_DELAY_SLOT    [i] = internal_CONTEXT_IS_DELAY_SLOT    [i];
 …
 //      for (uint32_t i=0; i<_param->_nb_context; i++)
 //        log_printf(TRACE,Decod,FUNCTION,"[%d] %.8x %d",i,reg_CONTEXT_ADDRESS_PREVIOUS [i], reg_CONTEXT_IS_DELAY_SLOT [i]);
+#ifdef STATISTICS
+        if (usage_is_set(_usage,USE_STATISTICS))
+          for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+            if (internal_DECOD_VAL [i] and PORT_READ(in_DECOD_ACK[i]))
+              (*_stat_sum_inst_decod) ++;
+#endif
+      }
 …
 #endif
     log_printf(FUNC,Decod,FUNCTION,"End");
+    log_end(Decod,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Parameters.cpp

-              r87
+              r88
 /*
  * $Id$
+ *
 …
                           uint32_t          * nb_inst_fetch                ,
                           uint32_t            nb_inst_decod                ,
                           uint32_t            nb_branch_speculated         ,
                           uint32_t            size_branch_update_prediction,
+                          uint32_t          * nb_branch_speculated         ,
+//                        uint32_t          * size_branch_update_prediction,
                           uint32_t            nb_context_select            ,
                           uint32_t            size_general_data            ,
 …
                           Tload_balancing_t   load_balancing               ,
                           bool             ** instruction_implemeted       ,
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t))
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                          bool                is_toplevel
+                          )
+  {
     log_printf(FUNC,Decod,FUNCTION,"Begin");
 …
     _nb_branch_speculated          = nb_branch_speculated         ;
     _nb_context_select             = nb_context_select            ;
     _size_branch_update_prediction = size_branch_update_prediction;
     _size_general_data             = size_general_data            ;
+//  _size_branch_update_prediction = size_branch_update_prediction;
+//  _size_general_data             = size_general_data            ;
     _priority                      = priority                     ;
     _load_balancing                = load_balancing               ;
 …
+    _max_nb_inst_fetch                     = max<uint32_t>(nb_inst_fetch,nb_context);
+    _max_nb_inst_fetch                        = max<uint32_t>(nb_inst_fetch,nb_context);
+//  _size_address_inst                        = size_general_data-2;
+    _size_address_inst                     = size_general_data-2;
+    _size_context_id                       = log2(nb_context          );
+    _size_depth                            = log2(nb_branch_speculated);
+    _size_inst_ifetch_ptr                  = log2(_max_nb_inst_fetch  );
+    test();
+    _have_port_context_id                  = _size_context_id > 0;
+    _have_port_depth                       = _size_depth      > 0;
+    _have_port_branch_update_prediction_id = _size_branch_update_prediction > 0;
+    _have_port_inst_ifetch_ptr             = _size_inst_ifetch_ptr > 0;
+    test();
+    if (is_toplevel)
+      {
+        _size_context_id                      = log2(nb_context          );
+        _size_depth                           = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
+//      _size_branch_update_prediction_id     = max<uint32_t>(_size_branch_update_prediction,_nb_context);
+        _size_inst_ifetch_ptr                 = log2(_max_nb_inst_fetch  );
+        _size_instruction_address             = size_general_data-2;
+        _size_general_data                    = size_general_data;
+        _have_port_context_id                 = _size_context_id > 0;
+        _have_port_depth                      = _size_depth                       > 0;
+//      _have_port_branch_update_prediction_id= _size_branch_update_prediction_id > 0;
+        _have_port_inst_ifetch_ptr            = _size_inst_ifetch_ptr             > 0;
+        copy ();
+      }
     log_printf(FUNC,Decod,FUNCTION,"End");
   };
 …
+  {
     log_printf(FUNC,Decod,FUNCTION,"Begin");
+    log_printf(FUNC,Decod,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Decod::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Decod,FUNCTION,"Begin");
     log_printf(FUNC,Decod,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Parameters_msg_error.cpp

-              r87
+              r88
       test.error(_("nb_inst_decod must be > 0.\n"));
     if ((_size_general_data != 32) and
         (_size_general_data != 64))
       test.error(_("size_general_data must be equal at 32 or 64 bits.\n"));
+//  if ((_size_general_data != 32) and
+//      (_size_general_data != 64))
+//    test.error(_("size_general_data must be equal at 32 or 64 bits.\n"));
     if ((_nb_branch_speculated == 0) or
         (_nb_branch_speculated > _nb_context))
       test.error(_("nb_branch_speculated must be in [1:nb_context].\n"));
+//     if ((_nb_branch_speculated == 0) or
+//      (_nb_branch_speculated > _nb_context))
+//       test.error(_("nb_branch_speculated must be in [1:nb_context].\n"));
     if ((_nb_context_select == 0) or
 …
     if (sum_inst_fetch < _nb_inst_decod)
       test.error(_("The sum of the _nb_context_select most nb_inst_fetch must be greater that _nb_inst_decod"));
+      test.error(_("The sum of the _nb_context_select most nb_inst_fetch must be greater that _nb_inst_decod\n"));
     if ((_priority != PRIORITY_ROUND_ROBIN))

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Parameters_print.cpp

r81	r88
30	30	xml.singleton_begin("nb_inst_decod "); xml.attribut("value",toString(_nb_inst_decod )); xml.singleton_end();
31	31	xml.singleton_begin("nb_branch_speculated "); xml.attribut("value",toString(_nb_branch_speculated )); xml.singleton_end();
32		xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
	32	// xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
33	33	xml.singleton_begin("nb_context_select "); xml.attribut("value",toString(_nb_context_select )); xml.singleton_end();
34	34	xml.singleton_begin("size_general_data "); xml.attribut("value",toString(_size_general_data )); xml.singleton_end();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/SelfTest/Makefile

r82	r88
24	24	library_clean : Decod_queue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/SelfTest/src/main.cpp

-              r82
+              r88
          _size_queue       ,
          _size_general_data,
+         _nb_branch_speculated);
+         _nb_branch_speculated,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/SelfTest/src/test.cpp

-              r82
+              r88
   ALLOC1_SC_SIGNAL( in_DECOD_IN_TYPE           ," in_DECOD_IN_TYPE          ",Ttype_t            ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DECOD_IN_OPERATION      ," in_DECOD_IN_OPERATION     ",Toperation_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL( in_DECOD_IN_NO_EXECUTE     ," in_DECOD_IN_NO_EXECUTE    ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DECOD_IN_IS_DELAY_SLOT  ," in_DECOD_IN_IS_DELAY_SLOT ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DECOD_IN_ADDRESS        ," in_DECOD_IN_ADDRESS       ",Tgeneral_data_t    ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL( in_DECOD_IN_NUM_REG_RE     ," in_DECOD_IN_NUM_REG_RE    ",Tspecial_address_t ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DECOD_IN_EXCEPTION_USE  ," in_DECOD_IN_EXCEPTION_USE ",Texception_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL( in_DECOD_IN_EXCEPTION      ," in_DECOD_IN_EXCEPTION     ",Texception_t       ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_VAL           ,"out_DECOD_OUT_VAL          ",Tcontrol_t         ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_TYPE          ,"out_DECOD_OUT_TYPE         ",Ttype_t            ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_OPERATION     ,"out_DECOD_OUT_OPERATION    ",Toperation_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_OUT_NO_EXECUTE    ,"out_DECOD_OUT_NO_EXECUTE   ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_IS_DELAY_SLOT ,"out_DECOD_OUT_IS_DELAY_SLOT",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_ADDRESS       ,"out_DECOD_OUT_ADDRESS      ",Tgeneral_data_t    ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_NUM_REG_RE    ,"out_DECOD_OUT_NUM_REG_RE   ",Tspecial_address_t ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OUT_EXCEPTION_USE ,"out_DECOD_OUT_EXCEPTION_USE",Texception_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_OUT_EXCEPTION     ,"out_DECOD_OUT_EXCEPTION    ",Texception_t       ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DEPTH_TAIL              ," in_DEPTH_TAIL             ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL( in_DEPTH_NB_BRANCH         ," in_DEPTH_NB_BRANCH        ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_DEPTH_MIN               ," in_DEPTH_MIN              ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_DEPTH_MAX               ," in_DEPTH_MAX              ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_NB_INST_ALL             ,"out_NB_INST_ALL            ",Tcounter_t         ,_param->_nb_context);
 …
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_TYPE           ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_OPERATION      ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_NO_EXECUTE     ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_IS_DELAY_SLOT  ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_ADDRESS        ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_NUM_REG_RE     ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_EXCEPTION_USE  ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_IN_EXCEPTION      ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_VAL           ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DECOD_OUT_ACK           ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_TYPE          ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_OPERATION     ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_NO_EXECUTE    ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_IS_DELAY_SLOT ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_ADDRESS       ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_NUM_REG_RE    ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_EXCEPTION_USE ,_param->_nb_inst_decod);
+  if (_param->_have_port_depth)
+    {
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DEPTH_TAIL              ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod_queue, in_DEPTH_NB_BRANCH         ,_param->_nb_context);
+    }
+  INSTANCE1_SC_SIGNAL(_Decod_queue,out_DECOD_OUT_EXCEPTION     ,_param->_nb_inst_decod);
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    if (_param->_have_port_depth)
+      INSTANCE_SC_SIGNAL(_Decod_queue, in_DEPTH_MIN  [i]);
+  INSTANCE1_SC_SIGNAL(_Decod_queue, in_DEPTH_MAX               ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod_queue,out_NB_INST_ALL             ,_param->_nb_context);
 …
   DELETE1_SC_SIGNAL( in_DECOD_IN_TYPE           ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL( in_DECOD_IN_OPERATION      ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DECOD_IN_NO_EXECUTE     ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL( in_DECOD_IN_IS_DELAY_SLOT  ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL( in_DECOD_IN_ADDRESS        ,_param->_nb_inst_decod);
 …
   DELETE1_SC_SIGNAL( in_DECOD_IN_NUM_REG_RE     ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL( in_DECOD_IN_EXCEPTION_USE  ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DECOD_IN_EXCEPTION      ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_OUT_VAL           ,_param->_nb_inst_decod);
 …
   DELETE1_SC_SIGNAL(out_DECOD_OUT_TYPE          ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_OUT_OPERATION     ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_OUT_NO_EXECUTE    ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_OUT_IS_DELAY_SLOT ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_OUT_ADDRESS       ,_param->_nb_inst_decod);
 …
   DELETE1_SC_SIGNAL(out_DECOD_OUT_NUM_REG_RE    ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_OUT_EXCEPTION_USE ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DEPTH_TAIL              ,_param->_nb_context);
+  DELETE1_SC_SIGNAL( in_DEPTH_NB_BRANCH         ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_DECOD_OUT_EXCEPTION     ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DEPTH_MIN               ,_param->_nb_context);
+  DELETE1_SC_SIGNAL( in_DEPTH_MAX               ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_NB_INST_ALL             ,_param->_nb_context);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/include/Decod_queue.h

-              r82
+              r88
   public    : Stat                           * _stat;
   private   : counter_t                     ** _stat_nb_inst;
+  private   : counter_t                      * _stat_use_queue;
 #endif
 …
   public    : SC_IN (Ttype_t            )  **  in_DECOD_IN_TYPE           ;//[nb_inst_decod]
   public    : SC_IN (Toperation_t       )  **  in_DECOD_IN_OPERATION      ;//[nb_inst_decod]
+  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_IN_NO_EXECUTE     ;//[nb_inst_decod]
   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_IN_IS_DELAY_SLOT  ;//[nb_inst_decod]
   public    : SC_IN (Tgeneral_data_t    )  **  in_DECOD_IN_ADDRESS        ;//[nb_inst_decod]
 …
   public    : SC_IN (Tspecial_address_t )  **  in_DECOD_IN_NUM_REG_RE     ;//[nb_inst_decod]
   public    : SC_IN (Texception_t       )  **  in_DECOD_IN_EXCEPTION_USE  ;//[nb_inst_decod]
+  public    : SC_IN (Texception_t       )  **  in_DECOD_IN_EXCEPTION      ;//[nb_inst_decod]
     // ~~~~~[ Interface : "decod_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_OUT(Ttype_t            )  ** out_DECOD_OUT_TYPE          ;//[nb_inst_decod]
   public    : SC_OUT(Toperation_t       )  ** out_DECOD_OUT_OPERATION     ;//[nb_inst_decod]
+  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_OUT_NO_EXECUTE    ;//[nb_inst_decod]
   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_OUT_IS_DELAY_SLOT ;//[nb_inst_decod]
   public    : SC_OUT(Tgeneral_data_t    )  ** out_DECOD_OUT_ADDRESS       ;//[nb_inst_decod]
 …
   public    : SC_OUT(Tspecial_address_t )  ** out_DECOD_OUT_NUM_REG_RE    ;//[nb_inst_decod]
   public    : SC_OUT(Texception_t       )  ** out_DECOD_OUT_EXCEPTION_USE ;//[nb_inst_decod]
+  public    : SC_OUT(Texception_t       )  ** out_DECOD_OUT_EXCEPTION     ;//[nb_inst_decod]
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tdepth_t           )  **  in_DEPTH_TAIL              ;//[nb_context]
   public    : SC_IN (Tdepth_t           )  **  in_DEPTH_NB_BRANCH         ;//[nb_context]
+  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_MIN               ;//[nb_context]
+  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_MAX               ;//[nb_context]
     // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/include/Parameters.h

-              r82
+              r88
   public : uint32_t            _nb_inst_decod        ;
   public : uint32_t            _size_queue           ;
   public : uint32_t            _size_general_data    ;
+//public : uint32_t            _size_general_data    ;
   public : uint32_t          * _nb_branch_speculated ; //[nb_context]
   public : uint32_t            _nb_bank              ;
   public : uint32_t            _size_bank            ;
-  public : uint32_t            _size_context_id      ;
-  public : uint32_t            _size_depth           ;
-  public : uint32_t            _size_nb_inst         ;
-  public : bool                _have_port_context_id ;
-  public : bool                _have_port_depth      ;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t   size_queue          ,
                         uint32_t   size_general_data   ,
+                        uint32_t * nb_branch_speculated);
+                        uint32_t * nb_branch_speculated,
+                        bool       is_toplevel=false   );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/include/Types.h

-              r82
+              r88
   public : Ttype_t            * _type           ;
   public : Toperation_t       * _operation      ;
+  public : Tcontrol_t         * _no_execute     ;
   public : Tcontrol_t         * _is_delay_slot  ;
   public : Tgeneral_data_t    * _address        ;
 …
   public : Tspecial_address_t * _num_reg_re     ;
   public : Texception_t       * _exception_use  ;
+  public : Texception_t       * _exception      ;
   public :  decod_queue_entry_t (uint32_t nb_inst):
 …
       _type           = new Ttype_t            [_nb_inst];
       _operation      = new Toperation_t       [_nb_inst];
+      _no_execute     = new Tcontrol_t         [_nb_inst];
       _is_delay_slot  = new Tcontrol_t         [_nb_inst];
       _address        = new Tgeneral_data_t    [_nb_inst];
 …
       _num_reg_re     = new Tspecial_address_t [_nb_inst];
       _exception_use  = new Texception_t       [_nb_inst];
+      _exception      = new Texception_t       [_nb_inst];
       for (uint32_t i=0; i<_nb_inst; i++)
 …
       delete [] _type           ;
       delete [] _operation      ;
+      delete [] _no_execute     ;
       delete [] _is_delay_slot  ;
       delete [] _address        ;
 …
       delete [] _num_reg_re     ;
       delete [] _exception_use  ;
+      delete [] _exception      ;
+    }
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue.cpp

-              r87
+              r88
     usage_environment(_usage);
+#if DEBUG_Decod_queue == true
+    log_printf(INFO,Decod_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Decod_queue,FUNCTION,_("Allocation"));
 …
         for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
           sensitive << (*(in_DECOD_OUT_ACK [i]));
-        if (_param->_have_port_depth)
           for (uint32_t i=0; i<_param->_nb_context; i++)
+            sensitive << (*(in_DEPTH_TAIL      [i]))
+                      << (*(in_DEPTH_NB_BRANCH [i]));
+            {
+              if (_param->_have_port_depth)
+              sensitive << (*(in_DEPTH_MIN [i]));
+              sensitive << (*(in_DEPTH_MAX [i]));
+            }
 # ifdef SYSTEMCASS_SPECIFIC
 …
+          {
             (*(out_DECOD_OUT_VAL [i])) (*(in_DECOD_OUT_ACK [i]));
             if (_param->_have_port_depth)
+              for (uint32_t j=0; j<_param->_nb_context; j++)
+                {
                   (*(out_DECOD_OUT_VAL [i])) (*(in_DEPTH_TAIL      [j]));
                   (*(out_DECOD_OUT_VAL [i])) (*(in_DEPTH_NB_BRANCH [j]));
+                }
+            for (uint32_t j=0; j<_param->_nb_context; j++)
+              {
+                if (_param->_have_port_depth)
+                (*(out_DECOD_OUT_VAL [i])) (*(in_DEPTH_MIN [j]));
+                (*(out_DECOD_OUT_VAL [i])) (*(in_DEPTH_MAX [j]));
+              }
+          }
 # endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_allocation.cpp

-              r82
+              r88
       ALLOC1_SIGNAL_IN ( in_DECOD_IN_TYPE           ,"type"         ,Ttype_t            ,_param->_size_type                  );
       ALLOC1_SIGNAL_IN ( in_DECOD_IN_OPERATION      ,"operation"    ,Toperation_t       ,_param->_size_operation             );
+      ALLOC1_SIGNAL_IN ( in_DECOD_IN_NO_EXECUTE     ,"no_execute"   ,Tcontrol_t         ,1                                   );
       ALLOC1_SIGNAL_IN ( in_DECOD_IN_IS_DELAY_SLOT  ,"is_delay_slot",Tcontrol_t         ,1                                   );
       ALLOC1_SIGNAL_IN ( in_DECOD_IN_ADDRESS        ,"address"      ,Tgeneral_data_t    ,_param->_size_general_data          );
 …
       ALLOC1_SIGNAL_IN ( in_DECOD_IN_NUM_REG_RE     ,"num_reg_re"   ,Tspecial_address_t ,_param->_size_special_register_logic);
       ALLOC1_SIGNAL_IN ( in_DECOD_IN_EXCEPTION_USE  ,"exception_use",Texception_t       ,_param->_size_exception_use         );
+      ALLOC1_SIGNAL_IN ( in_DECOD_IN_EXCEPTION      ,"exception"    ,Texception_t       ,_param->_size_exception_decod       );
+    }
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_TYPE           ,"type"         ,Ttype_t            ,_param->_size_type                  );
       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_OPERATION      ,"operation"    ,Toperation_t       ,_param->_size_operation             );
+      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_NO_EXECUTE     ,"no_execute"   ,Tcontrol_t         ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_IS_DELAY_SLOT  ,"is_delay_slot",Tcontrol_t         ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_ADDRESS        ,"address"      ,Tgeneral_data_t    ,_param->_size_general_data          );
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_NUM_REG_RE     ,"num_reg_re"   ,Tspecial_address_t ,_param->_size_special_register_logic);
       ALLOC1_SIGNAL_OUT(out_DECOD_OUT_EXCEPTION_USE  ,"exception_use",Texception_t       ,_param->_size_exception_use         );
+      ALLOC1_SIGNAL_OUT(out_DECOD_OUT_EXCEPTION      ,"exception"    ,Texception_t       ,_param->_size_exception_decod       );
+    }
 …
       ALLOC1_INTERFACE("depth",IN ,NORTH,"Depth", _param->_nb_context);
+      ALLOC1_SIGNAL_IN ( in_DEPTH_TAIL     ,"tail"     ,Tdepth_t           ,_param->_size_depth  );
+      if (_param->_have_port_depth)
+      ALLOC1_SIGNAL_IN ( in_DEPTH_NB_BRANCH,"nb_branch",Tdepth_t           ,_param->_size_depth+1);
+      ALLOC1_SIGNAL_IN ( in_DEPTH_MIN      ,"min"      ,Tdepth_t           ,_param->_size_depth  );
+      ALLOC1_SIGNAL_IN ( in_DEPTH_MAX      ,"max"      ,Tdepth_t           ,_param->_size_depth+1);
+    }
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC1_INTERFACE("nb_inst",OUT,NORTH,"Instruction's number", _param->_nb_context);
       ALLOC1_SIGNAL_OUT(out_NB_INST_ALL    ,"all"      ,Tcontext_t         ,_param->_size_nb_inst+1);
+      ALLOC1_SIGNAL_OUT(out_NB_INST_ALL    ,"all"      ,Tcontext_t         ,_param->_size_nb_inst_decod);
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     reg_QUEUE              = new std::list<decod_queue_entry_t*>;
 …
     internal_DECOD_OUT_VAL = new Tcontrol_t [_param->_nb_inst_decod];
     internal_DECOD_OUT_ACK = new Tcontrol_t [_param->_nb_inst_decod];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_deallocation.cpp

-              r82
+              r88
         DELETE1_SIGNAL( in_DECOD_IN_TYPE           ,_param->_nb_inst_decod,_param->_size_type                  );
         DELETE1_SIGNAL( in_DECOD_IN_OPERATION      ,_param->_nb_inst_decod,_param->_size_operation             );
+        DELETE1_SIGNAL( in_DECOD_IN_NO_EXECUTE     ,_param->_nb_inst_decod,1                                   );
         DELETE1_SIGNAL( in_DECOD_IN_IS_DELAY_SLOT  ,_param->_nb_inst_decod,1                                   );
         DELETE1_SIGNAL( in_DECOD_IN_ADDRESS        ,_param->_nb_inst_decod,_param->_size_general_data          );
 …
         DELETE1_SIGNAL( in_DECOD_IN_NUM_REG_RE     ,_param->_nb_inst_decod,_param->_size_special_register_logic);
         DELETE1_SIGNAL( in_DECOD_IN_EXCEPTION_USE  ,_param->_nb_inst_decod,_param->_size_exception_use         );
+        DELETE1_SIGNAL( in_DECOD_IN_EXCEPTION      ,_param->_nb_inst_decod,_param->_size_exception             );
         DELETE1_SIGNAL(out_DECOD_OUT_VAL           ,_param->_nb_inst_decod,1);
 …
         DELETE1_SIGNAL(out_DECOD_OUT_TYPE          ,_param->_nb_inst_decod,_param->_size_type                  );
         DELETE1_SIGNAL(out_DECOD_OUT_OPERATION     ,_param->_nb_inst_decod,_param->_size_operation             );
+        DELETE1_SIGNAL(out_DECOD_OUT_NO_EXECUTE    ,_param->_nb_inst_decod,1                                   );
         DELETE1_SIGNAL(out_DECOD_OUT_IS_DELAY_SLOT ,_param->_nb_inst_decod,1                                   );
         DELETE1_SIGNAL(out_DECOD_OUT_ADDRESS       ,_param->_nb_inst_decod,_param->_size_general_data          );
 …
         DELETE1_SIGNAL(out_DECOD_OUT_NUM_REG_RE    ,_param->_nb_inst_decod,_param->_size_special_register_logic);
         DELETE1_SIGNAL(out_DECOD_OUT_EXCEPTION_USE ,_param->_nb_inst_decod,_param->_size_exception_use         );
+        DELETE1_SIGNAL(out_DECOD_OUT_EXCEPTION     ,_param->_nb_inst_decod,_param->_size_exception             );
+        DELETE1_SIGNAL( in_DEPTH_TAIL     ,_param->_nb_context,_param->_size_depth  );
+        if (_param->_have_port_depth)
+        DELETE1_SIGNAL( in_DEPTH_NB_BRANCH,_param->_nb_context,_param->_size_depth+1);
+        DELETE1_SIGNAL( in_DEPTH_MIN               ,_param->_nb_context,_param->_size_depth  );
+        DELETE1_SIGNAL( in_DEPTH_MAX               ,_param->_nb_context,_param->_size_depth+1);
+        DELETE1_SIGNAL(out_NB_INST_ALL    ,_param->_nb_context,_param->_size_nb_inst+1);
+        DELETE1_SIGNAL(out_NB_INST_ALL             ,_param->_nb_context,_param->_size_nb_inst_decod);
+        // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete    reg_QUEUE;
+        delete [] reg_NB_INST;
+        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] internal_DECOD_IN_ACK ;
+        delete [] internal_DECOD_OUT_VAL;
+        delete [] internal_DECOD_OUT_ACK;
+      }
-    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete    reg_QUEUE;
-    delete [] reg_NB_INST;
-    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] internal_DECOD_IN_ACK ;
-    delete [] internal_DECOD_OUT_VAL;
-    delete [] internal_DECOD_OUT_ACK;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_genMealy_decod_out.cpp

-              r82
+              r88
+  {
     log_begin(Decod_queue,FUNCTION);
+    log_function(Decod_queue,FUNCTION,_name.c_str());
     Tcontrol_t val [_param->_nb_inst_decod];
 …
         if (reg_QUEUE->front()->_val [i])
+          {
             log_printf(TRACE,Decod_queue,FUNCTION,_("Queue is not empty, slot [%d] is valid."),i);
+            log_printf(TRACE,Decod_queue,FUNCTION,_("  * Queue is not empty, slot [%d] is valid."),i);
             Tcontext_t context         = reg_QUEUE->front()->_context_id    [i];
             Tdepth_t   depth           = reg_QUEUE->front()->_depth         [i];
+            Tdepth_t   depth_base      = (_param->_have_port_depth)?PORT_READ(in_DEPTH_TAIL      [context]):0;
+            Tdepth_t   depth_offset    = (_param->_have_port_depth)?PORT_READ(in_DEPTH_NB_BRANCH [context]):0;
+            Tdepth_t   depth_max       = depth_base + depth_offset;
+            Tdepth_t   depth_min       = (_param->_have_port_depth)?PORT_READ(in_DEPTH_MIN [context]):0;
+            Tdepth_t   depth_max       = PORT_READ(in_DEPTH_MAX[context]);
             // is a valid instruction ?
+            //  * depth must be lower that depth max
+            Tcontrol_t is_valid        = depth <= ((depth>depth_base)?(depth_max):(depth_max%_param->_nb_branch_speculated [context]));
+            // If DEPTH_CURRENT :
+            // equal at     DEPTH_MIN            -> not speculative
+            // not include ]DEPTH_MIN:DEPTH_MAX[ -> previous branch miss
+            //     include ]DEPTH_MIN:DEPTH_MAX[ -> speculative
+            log_printf(TRACE,Decod_queue,FUNCTION,_("  * is_valid : %d"),is_valid);
+            // All case
+            // ....... min ...X... max ....... OK
+            // ....... min ....... max ...X... KO
+            // ...X... min ....... max ....... KO
+            // ....... max ....... min ...X... OK
+            // ...X... max ....... min ....... OK
+            // ....... max ...X... min ....... KO
+            Tcontrol_t is_valid        = ((depth == depth_min) or
+                                          ((depth_min < depth_max)?
+                                           (depth<depth_max):
+                                           ((depth > depth_min) or (depth < depth_max))));
+//          Tcontrol_t is_valid        = depth <= depth_max;
+            log_printf(TRACE,Decod_queue,FUNCTION,_("    * is_valid : %d"),is_valid);
             internal_DECOD_OUT_VAL [i] = 1; // in all case, val is set (entry is not empty, and instruction is valid)
 …
     for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+      {
+        log_printf(TRACE,Decod_queue,FUNCTION,_("  * DECOD_OUT_VAL : %d"),val [i]);
         PORT_WRITE(out_DECOD_OUT_VAL [i],val [i]);
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_genMoore.cpp

-              r82
+              r88
+  {
     log_begin(Decod_queue,FUNCTION);
+    log_function(Decod_queue,FUNCTION,_name.c_str());
     //--------------------------------------------------------------------
 …
           PORT_WRITE(out_DECOD_OUT_TYPE          [i],reg_QUEUE->front()->_type          [i]);
           PORT_WRITE(out_DECOD_OUT_OPERATION     [i],reg_QUEUE->front()->_operation     [i]);
+          PORT_WRITE(out_DECOD_OUT_NO_EXECUTE    [i],reg_QUEUE->front()->_no_execute    [i]);
           PORT_WRITE(out_DECOD_OUT_IS_DELAY_SLOT [i],reg_QUEUE->front()->_is_delay_slot [i]);
           PORT_WRITE(out_DECOD_OUT_ADDRESS       [i],reg_QUEUE->front()->_address       [i]);
 …
           PORT_WRITE(out_DECOD_OUT_NUM_REG_RE    [i],reg_QUEUE->front()->_num_reg_re    [i]);
           PORT_WRITE(out_DECOD_OUT_EXCEPTION_USE [i],reg_QUEUE->front()->_exception_use [i]);
+          PORT_WRITE(out_DECOD_OUT_EXCEPTION     [i],reg_QUEUE->front()->_exception     [i]);
+        }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_statistics_allocation.cpp

-              r82
+              r88
                       param_statistics);
+    _stat_nb_inst = new counter_t * [_param->_nb_context];
+    _stat_use_queue = _stat->create_variable ("use_queue");
+    _stat_nb_inst   = new counter_t * [_param->_nb_context];
     std::string expr_average_inst = "";
 …
     for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
         _stat_nb_inst [i] = _stat->create_variable("nb_inst_"+toString(i));
         _stat->create_expr_average_by_cycle("average_inst_"+toString(i), "nb_inst_"+toString(i), "", toString(_("Average instruction by cycle (context %d)"),i));
         _stat->create_expr_percent         ("percent_use_inst_"+toString(i) , "average_inst_"+toString(i), toString(_param->_size_queue), toString(_("Percent instruction by cycle (context %d)"),i));
         if (i == 0)
           expr_average_inst = "nb_inst_"+toString(i);
+        _stat_nb_inst [i] = _stat->create_variable("nb_inst_"+toString(i));
+        _stat->create_expr_average_by_cycle("average_inst_"+toString(i), "nb_inst_"+toString(i), "", toString(_("Average instruction number in decod_queue by cycle (context %d)"),i));
+        _stat->create_expr_percent         ("percent_use_inst_"+toString(i) , "average_inst_"+toString(i), toString(_param->_size_queue), toString(_("Percent decod_queue's occupation (context %d)"),i));
+        if (i == 0)
+          expr_average_inst = "nb_inst_"+toString(i);
         else
           expr_average_inst = "+ nb_inst_"+toString(i) + " " +expr_average_inst;
+      }
+    _stat->create_expr_average_by_cycle("average_inst", expr_average_inst, "", _("Average instruction by cycle (all context)"));
+    _stat->create_expr_percent         ("percent_use_inst" , "average_inst", toString(_param->_size_queue), _("Percent instruction by cycle (all context)"));
+    _stat->create_expr_average_by_cycle("average_inst", expr_average_inst, "", _("Average instruction number in decod_queue by cycle (all context)"));
+    _stat->create_expr_percent         ("percent_use_inst" , "average_inst", toString(_param->_size_queue), _("Percent decod_queue's occupation (all context)"));
+    _stat->create_expr_average_by_cycle("average_use_queue", "use_queue", "", _("Average slot decod_queue occupation by cycle."));
+    _stat->create_expr_percent         ("percent_use_queue", "average_use_queue", toString(_param->_size_queue), _("Percent slot decod_queue occupation."));
     log_end(Decod_queue,FUNCTION);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Decod_queue_transition.cpp

-              r87
+              r88
+  {
     log_begin(Decod_queue,FUNCTION);
+    log_function(Decod_queue,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
         //--------------------------------------------------------------------
         //-----[ DECOD_IN ]---------------------------------------------------
+        //--------------------------------------------------------------------
+        for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+        //--------------------------------------------------------------------
+        decod_queue_entry_t * entry = NULL;
+        for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+          {
-            decod_queue_entry_t * entry = NULL;
             if (PORT_READ(in_DECOD_IN_VAL [i]) and internal_DECOD_IN_ACK[i])
+              {
                 log_printf(TRACE,Decod_queue,FUNCTION,_("DECOD_IN  [%d]"),i);
+                log_printf(TRACE,Decod_queue,FUNCTION,_("  * DECOD_IN  [%d]"),i);
                 if (entry == NULL)
+                  entry = new decod_queue_entry_t (_param->_nb_inst_decod);
+                 {
+                   // Once creation and insert in queue
+                   entry = new decod_queue_entry_t (_param->_nb_inst_decod);
+                   reg_QUEUE->push_back(entry);
+                 }
                 Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_DECOD_IN_CONTEXT_ID [i]):0;
                 log_printf(TRACE,Decod_queue,FUNCTION,_("  * context : %d"),context);
+                log_printf(TRACE,Decod_queue,FUNCTION,_("    * context : %d"),context);
                 entry->_val           [i] = 1;
 …
                 entry->_type          [i] = PORT_READ(in_DECOD_IN_TYPE          [i]);
                 entry->_operation     [i] = PORT_READ(in_DECOD_IN_OPERATION     [i]);
+                entry->_no_execute    [i] = PORT_READ(in_DECOD_IN_NO_EXECUTE    [i]);
                 entry->_is_delay_slot [i] = PORT_READ(in_DECOD_IN_IS_DELAY_SLOT [i]);
                 entry->_address       [i] = PORT_READ(in_DECOD_IN_ADDRESS       [i]);
 …
                 entry->_num_reg_re    [i] = PORT_READ(in_DECOD_IN_NUM_REG_RE    [i]);
                 entry->_exception_use [i] = PORT_READ(in_DECOD_IN_EXCEPTION_USE [i]);
+                entry->_exception     [i] = PORT_READ(in_DECOD_IN_EXCEPTION     [i]);
                 reg_NB_INST [context] ++;
-                reg_QUEUE->push_back(entry);
                 log_printf(TRACE,Decod_queue,FUNCTION,_("  * nb_inst : %d"),reg_NB_INST [context]);
                 log_printf(TRACE,Decod_queue,FUNCTION,_("  * PUSH queue"));
+                log_printf(TRACE,Decod_queue,FUNCTION,_("    * nb_inst : %d"),reg_NB_INST [context]);
+                log_printf(TRACE,Decod_queue,FUNCTION,_("    * PUSH queue"));
+              }
+          }
 …
                 if (internal_DECOD_OUT_VAL [i] and internal_DECOD_OUT_ACK[i])
+                  {
                     log_printf(TRACE,Decod_queue,FUNCTION,_("DECOD_OUT [%d]"),i);
+                    log_printf(TRACE,Decod_queue,FUNCTION,_("  * DECOD_OUT [%d]"),i);
                     reg_QUEUE->front()->_val [i] = 0;
                     Tcontext_t context = reg_QUEUE->front()->_context_id [i];
                     log_printf(TRACE,Decod_queue,FUNCTION,_("  * context : %d"),context);
+                    log_printf(TRACE,Decod_queue,FUNCTION,_("    * context : %d"),context);
                     reg_NB_INST [context] --;
                     log_printf(TRACE,Decod_queue,FUNCTION,_("  * nb_inst : %d"),reg_NB_INST [context]);
+                    log_printf(TRACE,Decod_queue,FUNCTION,_("    * nb_inst : %d"),reg_NB_INST [context]);
+                  }
                 // Test if slot is (again) valid, if yes, then have less one instruction in the entry
 …
             if (not find) // no valid instruction in current slot
+              {
                 log_printf(TRACE,Decod_queue,FUNCTION,_("  * POP  queue"));
+                log_printf(TRACE,Decod_queue,FUNCTION,_("    * POP  queue"));
                 // can pop the slot
 …
+      }
+#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Decod_queue)
+#if defined(DEBUG) and defined(DEBUG_Decod_queue) and (DEBUG >= DEBUG_TRACE)
+    log_printf(TRACE,Decod_queue,FUNCTION,"  * Dump decod_queue");
     uint32_t x=0;
     for (std::list<decod_queue_entry_t*>::iterator it=reg_QUEUE->begin();
 …
          it++)
+      {
         log_printf(TRACE,Decod_queue,FUNCTION,"[%d] ",x);
+        log_printf(TRACE,Decod_queue,FUNCTION,"    * [%d] ",x);
         for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+          {
             if ((*it)->_val [i])
               log_printf(TRACE,Decod_queue,FUNCTION," * [%d] %d, %d %d, %d %d %d, 0x%x, %d 0x%x, %d %d, %d %d, %d %d, %d %d, %d %d, %d "
+              log_printf(TRACE,Decod_queue,FUNCTION,"      * [%d] %d, %d %d, %d %d %d %d, 0x%x, %d 0x%x, %d %d, %d %d, %d %d, %d %d, %d %d, %d %d"
                          ,i
                          ,(*it)->_val           [i]
 …
                          ,(*it)->_type          [i]
                          ,(*it)->_operation     [i]
+                         ,(*it)->_no_execute    [i]
                          ,(*it)->_is_delay_slot [i]
                          ,(*it)->_address       [i]
 …
                          ,(*it)->_num_reg_re    [i]
                          ,(*it)->_exception_use [i]
+                         ,(*it)->_exception     [i]
                          );
             else
               log_printf(TRACE,Decod_queue,FUNCTION," * [%d] %d"
+              log_printf(TRACE,Decod_queue,FUNCTION,"      * [%d] %d"
                          ,i
                          ,(*it)->_val           [i]
 …
 #ifdef STATISTICS
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      *(_stat_nb_inst [i]) += reg_NB_INST [i];
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        *(_stat_use_queue) += reg_QUEUE->size();
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          *(_stat_nb_inst [i]) += reg_NB_INST [i];
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue/src/Parameters.cpp

-              r82
+              r88
 namespace morpheo {
 namespace behavioural {
+  namespace behavioural {
 namespace core {
 namespace multi_front_end {
 …
                           uint32_t   size_queue          ,
                           uint32_t   size_general_data   ,
+                          uint32_t * nb_branch_speculated)
+                          uint32_t * nb_branch_speculated,
+                          bool       is_toplevel         )
+  {
     log_begin(Decod_queue,FUNCTION);
 …
     _nb_inst_decod        = nb_inst_decod       ;
     _size_queue           = size_queue          ;
     _size_general_data    = size_general_data   ;
+//  _size_general_data    = size_general_data   ;
     _nb_branch_speculated = nb_branch_speculated;
 …
     _size_bank            = _size_queue / _nb_bank;
+    _size_context_id      = log2(nb_context);
+    _size_depth           = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
+    _size_nb_inst         = log2(_size_queue);
+    test();
+    _have_port_context_id = (_size_context_id > 0);
+    _have_port_depth      = (_size_depth      > 0);
+    test();
+    if (is_toplevel)
+      {
+        _size_context_id      = log2(nb_context);
+        _size_nb_inst_decod   = log2(_size_queue)+1;
+        _size_depth           = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
+        _size_general_data    = size_general_data;
+        _have_port_context_id = _size_context_id > 0;
+        _have_port_depth      = _size_depth > 0;
+        copy ();
+      }
     log_end(Decod_queue,FUNCTION);
   };
 …
+  {
     log_begin(Decod_queue,FUNCTION);
+    log_end(Decod_queue,FUNCTION);
+  };
+#undef  FUNCTION
+#define FUNCTION "Decod_queue::copy"
+  void Parameters::copy (void)
+  {
+    log_begin(Decod_queue,FUNCTION);
     log_end(Decod_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/SelfTest/Makefile

r83	r88
24	24	library_clean : Decod_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/SelfTest/config_min.cfg

r83	r88
6	6	32 32 +1 # size_general_data
7	7	1 1 +1 # nb_branch_speculated [0][nb_context]
8		~~1 1 +1 # size_branch_update_prediction~~
9	8	1 1 +1 # nb_context_select
10	9	1 1 +1 # select_priority

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/SelfTest/config_mono_context.cfg

r87	r88
6	6	32 32 +1 # size_general_data
7	7	1 1 *4 # nb_branch_speculated [0][nb_context]
8		~~0 1 +1 # size_branch_update_prediction~~
9	8	1 1 +1 # nb_context_select
10	9	1 1 +1 # select_priority

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/SelfTest/config_multi_context.cfg

-              r87
+              r88
        4       +1      # nb_context
        4       *4      # nb_inst_fetch                [0][nb_context]
+       2       *4      # nb_inst_fetch                [1][nb_context]
+       1       *4      # nb_inst_fetch                [2][nb_context]
+       8       *4      # nb_inst_fetch                [3][nb_context]
+       8       *4      # nb_inst_decod
+      16      *4      # size_queue
+      32      +1      # size_general_data
+       1       *4      # nb_branch_speculated         [0][nb_context]
+       2       *4      # nb_branch_speculated         [1][nb_context]
+       1       *4      # nb_branch_speculated         [2][nb_context]
+       4       *4      # nb_branch_speculated         [3][nb_context]
+       2       +1      # size_branch_update_prediction
+       2       *4      # nb_inst_fetch                 [1][nb_context]
+       1       *4      # nb_inst_fetch                 [2][nb_context]
+       8       *4      # nb_inst_fetch                 [3][nb_context]
+       8       *4      # nb_inst_decod
+      16      *4      # size_queue
+      32      +1      # size_general_data
+       1       *4      # nb_branch_speculated          [0][nb_context]
+       2       *4      # nb_branch_speculated          [1][nb_context]
+       1       *4      # nb_branch_speculated          [2][nb_context]
+       4       *4      # nb_branch_speculated          [3][nb_context]
        4       *4      # nb_context_select
        1       +1      # select_priority

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/SelfTest/src/main.cpp

-              r87
+              r88
 #include "Behavioural/Custom/include/Custom_example.h"
 #define NB_PARAMS 8
+#define NB_PARAMS 7
 void usage (int argc, char * argv[])
 …
   err (_(" * size_general_data                          (uint32_t         )\n"));
   err (_(" * nb_branch_speculated          [nb_context] (uint32_t         )\n"));
-  err (_(" * size_branch_update_prediction              (uint32_t         )\n"));
   err (_(" * nb_context_select                          (uint32_t         )\n"));
   err (_(" * select_priority                            (Tpriority_t      )\n"));
 …
   for (uint32_t i=0; i<_nb_context; i++)
     _nb_branch_speculated [i] = fromString<uint32_t>(argv[x++]);
-  uint32_t            _size_branch_update_prediction= fromString<uint32_t         >(argv[x++]);
   uint32_t            _nb_context_select            = fromString<uint32_t         >(argv[x++]);
   Tpriority_t         _select_priority              = fromString<Tpriority_t      >(argv[x++]);
 …
          _size_general_data            ,
          _nb_branch_speculated         ,
-         _size_branch_update_prediction,
          _nb_context_select            ,
          _select_priority              ,
          _select_load_balancing        ,
          _instruction_implemeted       ,
+         &(morpheo::behavioural::custom::example_get_custom_information)
+         &(morpheo::behavioural::custom::example_get_custom_information),
+         true
          );

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/SelfTest/src/test.cpp

-              r87
+              r88
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
   ALLOC2_SC_SIGNAL( in_IFETCH_VAL                         ," in_IFETCH_VAL                         ",Tcontrol_t         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL(out_IFETCH_ACK                         ,"out_IFETCH_ACK                         ",Tcontrol_t         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ," in_IFETCH_INSTRUCTION                 ",Tinstruction_t     ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_IFETCH_VAL                         ," in_IFETCH_VAL                         ",Tcontrol_t         ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+  ALLOC2_SC_SIGNAL(out_IFETCH_ACK                         ,"out_IFETCH_ACK                         ",Tcontrol_t         ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+  ALLOC2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ," in_IFETCH_INSTRUCTION                 ",Tinstruction_t     ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
   ALLOC1_SC_SIGNAL(in_IFETCH_CONTEXT_ID                   ,"in_IFETCH_CONTEXT_ID                   ",Tcontext_t         ,_param->_nb_context);
 …
   ALLOC1_SC_SIGNAL(in_IFETCH_BRANCH_STATE                 ,"in_IFETCH_BRANCH_STATE                 ",Tbranch_state_t    ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID  ,"in_IFETCH_BRANCH_UPDATE_PREDICTION_ID  ",Tprediction_ptr_t  ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(in_IFETCH_EXCEPTION                    ,"in_IFETCH_EXCEPTION                    ",Texception_t       ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_DECOD_VAL                          ,"out_DECOD_VAL                          ",Tcontrol_t         ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_TYPE                         ,"out_DECOD_TYPE                         ",Ttype_t            ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_OPERATION                    ,"out_DECOD_OPERATION                    ",Toperation_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_NO_EXECUTE                   ,"out_DECOD_NO_EXECUTE                   ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_IS_DELAY_SLOT                ,"out_DECOD_IS_DELAY_SLOT                ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_ADDRESS                      ,"out_DECOD_ADDRESS                      ",Tgeneral_data_t    ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_NUM_REG_RE                   ,"out_DECOD_NUM_REG_RE                   ",Tspecial_address_t ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_EXCEPTION_USE                ,"out_DECOD_EXCEPTION_USE                ",Texception_t       ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_EXCEPTION                    ,"out_DECOD_EXCEPTION                    ",Texception_t       ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_PREDICT_VAL                        ,"out_PREDICT_VAL                        ",Tcontrol_t         ,_param->_nb_inst_decod);
 …
 //ALLOC1_SC_SIGNAL( in_PREDICT_CAN_CONTINUE               ," in_PREDICT_CAN_CONTINUE               ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_DEPTH_TAIL                         ," in_DEPTH_TAIL                         ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL( in_DEPTH_NB_BRANCH                    ," in_DEPTH_NB_BRANCH                    ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_DEPTH_MIN                          ," in_DEPTH_MIN                          ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL( in_DEPTH_MAX                          ," in_DEPTH_MAX                          ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_NB_INST_DECOD_ALL                  ,"out_NB_INST_DECOD_ALL                  ",Tcounter_t         ,_param->_nb_context);
 …
   ALLOC_SC_SIGNAL(  in_CONTEXT_EVENT_ACK                  ," in_CONTEXT_EVENT_ACK                  ",Tcontrol_t         );
   ALLOC_SC_SIGNAL( out_CONTEXT_EVENT_CONTEXT_ID           ,"out_CONTEXT_EVENT_CONTEXT_ID           ",Tcontext_t         );
+  ALLOC_SC_SIGNAL( out_CONTEXT_EVENT_DEPTH                ,"out_CONTEXT_EVENT_DEPTH                ",Tdepth_t           );
   ALLOC_SC_SIGNAL( out_CONTEXT_EVENT_TYPE                 ,"out_CONTEXT_EVENT_TYPE                 ",Tevent_type_t      );
   ALLOC_SC_SIGNAL( out_CONTEXT_EVENT_IS_DELAY_SLOT        ,"out_CONTEXT_EVENT_IS_DELAY_SLOT        ",Tcontrol_t         );
 …
   (*(_Decod_unit->in_NRESET))       (*(in_NRESET));
   INSTANCE2_SC_SIGNAL(_Decod_unit, in_IFETCH_VAL                         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Decod_unit,out_IFETCH_ACK                         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Decod_unit, in_IFETCH_INSTRUCTION                 ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Decod_unit, in_IFETCH_VAL                         ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+  INSTANCE2_SC_SIGNAL(_Decod_unit,out_IFETCH_ACK                         ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+  INSTANCE2_SC_SIGNAL(_Decod_unit, in_IFETCH_INSTRUCTION                 ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_CONTEXT_ID                   ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_ADDRESS                      ,_param->_nb_context);
 //INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_ADDRESS_NEXT                 ,_param->_nb_context);
+  if (_param->_have_port_inst_ifetch_ptr)
+  INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_INST_IFETCH_PTR              ,_param->_nb_context);
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    {
+      if (_param->_have_port_inst_ifetch_ptr)
+        INSTANCE_SC_SIGNAL(_Decod_unit,in_IFETCH_INST_IFETCH_PTR[i]);
+      if (_param->_have_port_depth)
+        INSTANCE_SC_SIGNAL(_Decod_unit,in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [i]);
+    }
   INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_BRANCH_STATE                 ,_param->_nb_context);
+  if (_param->_have_port_branch_update_prediction_id)
+  INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_BRANCH_UPDATE_PREDICTION_ID  ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Decod_unit,in_IFETCH_EXCEPTION                    ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_VAL                          ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_TYPE                         ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_OPERATION                    ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_NO_EXECUTE                   ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_IS_DELAY_SLOT                ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_ADDRESS                      ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_NUM_REG_RE                   ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_EXCEPTION_USE                ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Decod_unit,out_DECOD_EXCEPTION                    ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_PREDICT_VAL                        ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod);
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod);
 …
 //INSTANCE1_SC_SIGNAL(_Decod_unit, in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod);
+  if (_param->_have_port_depth)
+    {
+  INSTANCE1_SC_SIGNAL(_Decod_unit, in_DEPTH_TAIL                         ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Decod_unit, in_DEPTH_NB_BRANCH                    ,_param->_nb_context);
+    }
+  INSTANCE1_SC_SIGNAL(_Decod_unit, in_DEPTH_MAX                          ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod_unit,out_NB_INST_DECOD_ALL                  ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Decod_unit, in_CONTEXT_DECOD_ENABLE               ,_param->_nb_context);
+  if (_param->_have_port_depth)
+  INSTANCE1_SC_SIGNAL(_Decod_unit, in_CONTEXT_DEPTH                      ,_param->_nb_context);
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    if (_param->_have_port_depth)
+      {
+        INSTANCE_SC_SIGNAL(_Decod_unit, in_DEPTH_MIN     [i]);
+        INSTANCE_SC_SIGNAL(_Decod_unit, in_CONTEXT_DEPTH [i]);
+      }
   INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_VAL                  );
 …
   if (_param->_have_port_context_id)
   INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_CONTEXT_ID           );
+  if (_param->_have_port_depth)
+  INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_DEPTH                );
   INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_TYPE                 );
   INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_IS_DELAY_SLOT        );
   INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_ADDRESS              );
   INSTANCE_SC_SIGNAL( _Decod_unit,out_CONTEXT_EVENT_ADDRESS_EPCR         );
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
           delay_slot_next     [i] = false;
           in_DEPTH_TAIL      [i]->write(0);
           in_DEPTH_NB_BRANCH [i]->write(0);
+          in_DEPTH_MIN       [i]->write(0);
+          in_DEPTH_MAX       [i]->write(0);
           in_CONTEXT_DEPTH   [i]->write(0);
+        }
 …
                           in_IFETCH_BRANCH_STATE                [i]->write(it->_branch_state);
                           in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [i]->write(it->_branch_update_prediction_id);
+                          in_IFETCH_EXCEPTION                   [i]->write(it->_exception_ifetch);
                           if ((it->_is_delay_slot) or
 …
                       TEST(Tcontrol_t         , out_PREDICT_MATCH_INST_IFETCH_PTR       [x]->read(),((entry._address)%_param->_nb_inst_fetch[i]) == 0);
                       TEST(Tbranch_state_t    , out_PREDICT_BRANCH_STATE                [x]->read(), entry._branch_state               );
                       if (_param->_have_port_branch_update_prediction_id)
+                      if (_param->_have_port_depth)
                       TEST(Tprediction_ptr_t  , out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x]->read(), entry._branch_update_prediction_id);
                       TEST(Tbranch_condition_t, out_PREDICT_BRANCH_CONDITION            [x]->read(), entry._branch_condition           );
 …
                       if (_param->_have_port_context_id)
+                        TEST(Tcontext_t     ,out_CONTEXT_EVENT_CONTEXT_ID   ->read(), i);
+                      TEST(Tcontext_t     ,out_CONTEXT_EVENT_CONTEXT_ID   ->read(), i);
+                      if (_param->_have_port_depth)
+                      TEST(Tcontext_t     ,out_CONTEXT_EVENT_DEPTH        ->read(), entry._depth);
                       TEST(Tevent_type_t  ,out_CONTEXT_EVENT_TYPE         ->read(), entry._context_event_type);
                       TEST(Tcontrol_t     ,out_CONTEXT_EVENT_IS_DELAY_SLOT->read(), entry._is_delay_slot);
 …
                 TEST(Ttype_t           ,  out_DECOD_TYPE          [i]->read(), respons [context].front()._type         );
                 TEST(Toperation_t      ,  out_DECOD_OPERATION     [i]->read(), respons [context].front()._operation    );
+//              TEST(Tcontrol_t        ,  out_DECOD_NO_EXECUTE    [i]->read(), respons [context].front()._no_execute   );
                 TEST(Tcontrol_t        ,  out_DECOD_IS_DELAY_SLOT [i]->read(), respons [context].front()._is_delay_slot);
                 TEST(Tgeneral_data_t   ,  out_DECOD_ADDRESS       [i]->read(), respons [context].front()._address      );
 …
                 TEST(Tspecial_address_t,  out_DECOD_NUM_REG_RE    [i]->read(), respons [context].front()._num_reg_re   );
                 TEST(Texception_t      ,  out_DECOD_EXCEPTION_USE [i]->read(), respons [context].front()._exception_use);
+//              TEST(Texception_t      ,  out_DECOD_EXCEPTION     [i]->read(), respons [context].front()._exception    );
                 respons [context].pop_front();
 …
   delete in_NRESET;
   DELETE2_SC_SIGNAL( in_IFETCH_VAL                         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
   DELETE2_SC_SIGNAL(out_IFETCH_ACK                         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
+  DELETE2_SC_SIGNAL( in_IFETCH_VAL                         ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+  DELETE2_SC_SIGNAL(out_IFETCH_ACK                         ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+  DELETE2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ,_param->_nb_context, _param->_nb_inst_fetch[it1]);
   DELETE1_SC_SIGNAL(in_IFETCH_CONTEXT_ID                   ,_param->_nb_context);
   DELETE1_SC_SIGNAL(in_IFETCH_ADDRESS                      ,_param->_nb_context);
 …
   DELETE1_SC_SIGNAL(in_IFETCH_BRANCH_STATE                 ,_param->_nb_context);
   DELETE1_SC_SIGNAL(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID  ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(in_IFETCH_EXCEPTION                    ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_DECOD_VAL                          ,_param->_nb_inst_decod);
 …
   DELETE1_SC_SIGNAL(out_DECOD_TYPE                         ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_OPERATION                    ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_NO_EXECUTE                   ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_IS_DELAY_SLOT                ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_ADDRESS                      ,_param->_nb_inst_decod);
 …
   DELETE1_SC_SIGNAL(out_DECOD_NUM_REG_RE                   ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_DECOD_EXCEPTION_USE                ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_EXCEPTION                    ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL(out_PREDICT_VAL                        ,_param->_nb_inst_decod);
 …
 //DELETE1_SC_SIGNAL( in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod);
   DELETE1_SC_SIGNAL( in_DEPTH_TAIL                         ,_param->_nb_context);
   DELETE1_SC_SIGNAL( in_DEPTH_NB_BRANCH                    ,_param->_nb_context);
+  DELETE1_SC_SIGNAL( in_DEPTH_MIN                          ,_param->_nb_context);
+  DELETE1_SC_SIGNAL( in_DEPTH_MAX                          ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_NB_INST_DECOD_ALL                  ,_param->_nb_context);
 …
   DELETE_SC_SIGNAL(  in_CONTEXT_EVENT_ACK                  );
   DELETE_SC_SIGNAL( out_CONTEXT_EVENT_CONTEXT_ID           );
+  DELETE_SC_SIGNAL( out_CONTEXT_EVENT_DEPTH                );
   DELETE_SC_SIGNAL( out_CONTEXT_EVENT_TYPE                 );
   DELETE_SC_SIGNAL( out_CONTEXT_EVENT_IS_DELAY_SLOT        );

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/include/Decod_unit.h

-              r83
+              r88
   public    : SC_IN (Tbranch_state_t    )  **  in_IFETCH_BRANCH_STATE                ;//[nb_context]
   public    : SC_IN (Tprediction_ptr_t  )  **  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;//[nb_context]
+  public    : SC_IN (Texception_t       )  **  in_IFETCH_EXCEPTION                   ;//[nb_context]
     // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_OUT(Ttype_t            )  ** out_DECOD_TYPE                         ;//[nb_inst_decod]
   public    : SC_OUT(Toperation_t       )  ** out_DECOD_OPERATION                    ;//[nb_inst_decod]
+  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_NO_EXECUTE                   ;//[nb_inst_decod]
   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_IS_DELAY_SLOT                ;//[nb_inst_decod]
   public    : SC_OUT(Tgeneral_data_t    )  ** out_DECOD_ADDRESS                      ;//[nb_inst_decod]
 …
   public    : SC_OUT(Tspecial_address_t )  ** out_DECOD_NUM_REG_RE                   ;//[nb_inst_decod]
   public    : SC_OUT(Texception_t       )  ** out_DECOD_EXCEPTION_USE                ;//[nb_inst_decod]
+  public    : SC_OUT(Texception_t       )  ** out_DECOD_EXCEPTION                    ;//[nb_inst_decod]
     // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tdepth_t           )  **  in_DEPTH_TAIL              ;//[nb_context]
   public    : SC_IN (Tdepth_t           )  **  in_DEPTH_NB_BRANCH         ;//[nb_context]
+  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_MIN                          ;//[nb_context]
+  public    : SC_IN (Tdepth_t           )  **  in_DEPTH_MAX                          ;//[nb_context]
     // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcounter_t         )  ** out_NB_INST_DECOD_ALL       ;//[nb_context]
+  public    : SC_OUT(Tcounter_t         )  ** out_NB_INST_DECOD_ALL                  ;//[nb_context]
     // ~~~~~[ Interface : "context" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_IN (Tcontrol_t         )   *  in_CONTEXT_EVENT_ACK                  ;
   public    : SC_OUT(Tcontext_t         )   * out_CONTEXT_EVENT_CONTEXT_ID           ;
+  public    : SC_OUT(Tcontext_t         )   * out_CONTEXT_EVENT_DEPTH                ;
   public    : SC_OUT(Tevent_type_t      )   * out_CONTEXT_EVENT_TYPE                 ;
   public    : SC_OUT(Tcontrol_t         )   * out_CONTEXT_EVENT_IS_DELAY_SLOT        ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/include/Parameters.h

-              r87
+              r88
   public : uint32_t            _nb_inst_decod                ;
   public : uint32_t            _size_queue                   ;
   public : uint32_t            _size_general_data            ;
+//public : uint32_t            _size_general_data            ;
   public : uint32_t          * _nb_branch_speculated         ; //[nb_context]
+  public : uint32_t            _size_branch_update_prediction;
+//public : uint32_t          * _size_branch_update_prediction; //[nb_context]
   public : uint32_t            _nb_context_select            ;
   public : Tpriority_t         _select_priority              ;
   public : Tload_balancing_t   _select_load_balancing        ;
   public : bool             ** _instruction_implemeted       ; //[nb_context][nb_instruction]
   public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (uint32_t);
+  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void);
+  public : uint32_t            _size_nb_inst_decod                   ;
+  public : uint32_t            _max_nb_inst_fetch                    ;
+  public : uint32_t            _size_address_inst                    ;
+  public : uint32_t            _size_context_id                      ;
+  public : uint32_t            _size_depth                           ;
+  public : uint32_t            _size_inst_ifetch_ptr                 ;
+  public : bool                _have_port_context_id                 ;
+  public : bool                _have_port_depth                      ;
+  public : bool                _have_port_branch_update_prediction_id;
+  public : bool                _have_port_inst_ifetch_ptr            ;
+//public : uint32_t            _size_address_inst;
+  public : uint32_t            _max_nb_inst_fetch;
   public : morpheo::behavioural::core::multi_front_end::front_end::decod_unit::decod      ::Parameters * _param_decod;
 …
                         uint32_t            size_general_data            ,
                         uint32_t          * nb_branch_speculated         ,
                         uint32_t            size_branch_update_prediction,
+//                      uint32_t          * size_branch_update_prediction,
                         uint32_t            nb_context_select            ,
                         Tpriority_t         select_priority              ,
                         Tload_balancing_t   select_load_balancing        ,
                         bool             ** instruction_implemeted       ,
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t));
+                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                        bool                is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/src/Decod_unit.cpp

-              r83
+              r88
     usage_environment(_usage);
+#if DEBUG_Decod_unit == true
+    log_printf(INFO,Decod_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Decod_unit,FUNCTION,_("Allocation"));

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/src/Decod_unit_allocation.cpp

-              r87
+              r88
     // ~~~~~[ Interface : "ifetch" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC2_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context, _param->_nb_inst_fetch[alloc_interface_it1]);
       _ALLOC2_VALACK_IN ( in_IFETCH_VAL        ,VAL, _param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
       _ALLOC2_VALACK_OUT(out_IFETCH_ACK        ,ACK, _param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
       _ALLOC2_SIGNAL_IN ( in_IFETCH_INSTRUCTION,"instruction", Tinstruction_t, _param->_size_instruction,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
+      ALLOC2_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context, _param->_nb_inst_fetch[it1]);
+      _ALLOC2_VALACK_IN ( in_IFETCH_VAL        ,VAL, _param->_nb_context, _param->_nb_inst_fetch[it1]);
+      _ALLOC2_VALACK_OUT(out_IFETCH_ACK        ,ACK, _param->_nb_context, _param->_nb_inst_fetch[it1]);
+      _ALLOC2_SIGNAL_IN ( in_IFETCH_INSTRUCTION,"instruction", Tinstruction_t, _param->_size_instruction,_param->_nb_context, _param->_nb_inst_fetch[it1]);
+    }
+    {
       ALLOC1_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context);
+      ALLOC1_SIGNAL_IN (in_IFETCH_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id              );
+      ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS                    ,"address"                    ,Tgeneral_address_t ,_param->_size_address_inst            );
+//    ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS_NEXT               ,"address_next"               ,Tgeneral_address_t ,_param->_size_address_inst            );
+      ALLOC1_SIGNAL_IN (in_IFETCH_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr         );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
+      ALLOC1_SIGNAL_IN (in_IFETCH_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      );
+      ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS                    ,"address"                    ,Tgeneral_address_t ,_param->_size_instruction_address    );
+//    ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS_NEXT               ,"address_next"               ,Tgeneral_address_t ,_param->_size_instruction_address    );
+      ALLOC1_SIGNAL_IN (in_IFETCH_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    );
+      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           );
+      ALLOC1_SIGNAL_IN (in_IFETCH_EXCEPTION                  ,"exception"                  ,Texception_t       ,_param->_size_exception_ifetch);
+    }
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type                  );
       ALLOC1_SIGNAL_OUT(out_DECOD_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation             );
+      ALLOC1_SIGNAL_OUT(out_DECOD_NO_EXECUTE   ,"no_execute"   ,Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_address_inst          );
+      ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_instruction_address          );
       ALLOC1_SIGNAL_OUT(out_DECOD_HAS_IMMEDIAT ,"has_immediat" ,Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_DECOD_IMMEDIAT     ,"immediat"     ,Tgeneral_data_t   ,_param->_size_general_data          );
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register_logic);
       ALLOC1_SIGNAL_OUT(out_DECOD_EXCEPTION_USE,"exception_use",Texception_t      ,_param->_size_exception_use         );
+      ALLOC1_SIGNAL_OUT(out_DECOD_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception_decod       );
+    }
 …
       ALLOC1_VALACK_OUT(out_PREDICT_VAL                        ,VAL);
       ALLOC1_VALACK_IN ( in_PREDICT_ACK                        ,ACK);
       ALLOC1_SIGNAL_OUT(out_PREDICT_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id              );
       ALLOC1_SIGNAL_OUT(out_PREDICT_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                                     );
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition        );
 //    ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STACK_WRITE         ,"branch_stack_write"         ,Tcontrol_t         ,1                                     );
       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                                     );
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC                ,"address_src"                ,Tgeneral_data_t    ,_param->_size_address_inst            );
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST               ,"address_dest"               ,Tgeneral_data_t    ,_param->_size_address_inst            );
 //    ALLOC1_SIGNAL_IN ( in_PREDICT_CAN_CONTINUE               ,"can_continue"               ,Tcontrol_t         ,1                                     );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition);
+//    ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STACK_WRITE         ,"branch_stack_write"         ,Tcontrol_t         ,1                             );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC                ,"address_src"                ,Tgeneral_data_t    ,_param->_size_instruction_address    );
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST               ,"address_dest"               ,Tgeneral_data_t    ,_param->_size_instruction_address    );
+//    ALLOC1_SIGNAL_IN ( in_PREDICT_CAN_CONTINUE               ,"can_continue"               ,Tcontrol_t         ,1                             );
+    }
 …
       ALLOC1_INTERFACE("depth",IN ,NORTH,"Depth", _param->_nb_context);
+      ALLOC1_SIGNAL_IN ( in_DEPTH_TAIL     ,"tail"     ,Tdepth_t           ,_param->_size_depth  );
+      if (_param->_have_port_depth)
+      ALLOC1_SIGNAL_IN ( in_DEPTH_NB_BRANCH,"nb_branch",Tdepth_t           ,_param->_size_depth+1);
+    }
+    // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      ALLOC1_SIGNAL_IN ( in_DEPTH_MIN      ,"min"      ,Tdepth_t           ,_param->_size_depth  );
+      ALLOC1_SIGNAL_IN ( in_DEPTH_MAX      ,"max"      ,Tdepth_t           ,_param->_size_depth+1);
+    }
+    // ~~~~~[ Interface : "nb_inst" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC1_INTERFACE("nb_inst",OUT,NORTH,"Instruction's number", _param->_nb_context);
       ALLOC1_SIGNAL_OUT(out_NB_INST_DECOD_ALL  ,"decod_all"   ,Tcontext_t         ,_param->_size_nb_inst_decod+1);
+      ALLOC1_SIGNAL_OUT(out_NB_INST_DECOD_ALL  ,"decod_all"   ,Tcontext_t         ,_param->_size_nb_inst_decod);
+    }
 …
       ALLOC_VALACK_IN ( in_CONTEXT_EVENT_ACK          ,ACK);
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id  );
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_DEPTH        ,"depth"        ,Tdepth_t       ,_param->_size_depth       );
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_TYPE         ,"type"         ,Tevent_type_t  ,_param->_size_event_type  );
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t     ,1                         );
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_address_inst);
       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS_EPCR ,"address_epcr" ,Tgeneral_data_t,_param->_size_address_inst);
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS_EPCR ,"address_epcr" ,Tgeneral_data_t,_param->_size_instruction_address);
+    }
 …
           PORT_MAP(_component,src , "in_IFETCH_"+toString(i)+"_BRANCH_STATE"               ,
                               dest, "in_IFETCH_"+toString(i)+"_BRANCH_STATE"               );
           if (_param->_have_port_branch_update_prediction_id)
+          if (_param->_have_port_depth)
           PORT_MAP(_component,src , "in_IFETCH_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID",
                               dest, "in_IFETCH_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID");
+          PORT_MAP(_component,src , "in_IFETCH_"+toString(i)+"_EXCEPTION"                  ,
+                              dest, "in_IFETCH_"+toString(i)+"_EXCEPTION"                  );
+        }
 …
           COMPONENT_MAP(_component,src ,"out_DECOD_"   +toString(i)+"_OPERATION"    ,
                                    dest, "in_DECOD_IN_"+toString(i)+"_OPERATION"    );
+          COMPONENT_MAP(_component,src ,"out_DECOD_"   +toString(i)+"_NO_EXECUTE"   ,
+                                   dest, "in_DECOD_IN_"+toString(i)+"_NO_EXECUTE"   );
           COMPONENT_MAP(_component,src ,"out_DECOD_"   +toString(i)+"_IS_DELAY_SLOT",
                                    dest, "in_DECOD_IN_"+toString(i)+"_IS_DELAY_SLOT");
 …
           COMPONENT_MAP(_component,src ,"out_DECOD_"   +toString(i)+"_EXCEPTION_USE",
                                    dest, "in_DECOD_IN_"+toString(i)+"_EXCEPTION_USE");
+          COMPONENT_MAP(_component,src ,"out_DECOD_"   +toString(i)+"_EXCEPTION"    ,
+                                   dest, "in_DECOD_IN_"+toString(i)+"_EXCEPTION"    );
+        }
 …
           PORT_MAP(_component,src ,"out_PREDICT_"+toString(i)+"_BRANCH_STATE"               ,
                               dest,"out_PREDICT_"+toString(i)+"_BRANCH_STATE"               );
           if (_param->_have_port_branch_update_prediction_id)
+          if (_param->_have_port_depth)
           PORT_MAP(_component,src ,"out_PREDICT_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID",
                               dest,"out_PREDICT_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID");
 …
         PORT_MAP(_component,src ,"out_CONTEXT_EVENT_CONTEXT_ID"   ,
                             dest,"out_CONTEXT_EVENT_CONTEXT_ID"   );
+        if (_param->_have_port_depth)
+        PORT_MAP(_component,src ,"out_CONTEXT_EVENT_DEPTH"        ,
+                            dest,"out_CONTEXT_EVENT_DEPTH"        );
         PORT_MAP(_component,src ,"out_CONTEXT_EVENT_TYPE"         ,
                             dest,"out_CONTEXT_EVENT_TYPE"         );
 …
       // in_DECOD_IN_TYPE           - component decod
       // in_DECOD_IN_OPERATION      - component decod
+      // in_DECOD_IN_NO_EXECUTE     - component decod
       // in_DECOD_IN_IS_DELAY_SLOT  - component decod
       // in_DECOD_IN_ADDRESS        - component decod
 …
       // in_DECOD_IN_NUM_REG_RE     - component decod
       // in_DECOD_IN_EXCEPTION_USE  - component decod
+      // in_DECOD_IN_EXCEPTION      - component decod
       for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
 …
           PORT_MAP(_component,src ,"out_DECOD_OUT_"+toString(i)+"_OPERATION"    ,
                               dest,"out_DECOD_"    +toString(i)+"_OPERATION"    );
+          PORT_MAP(_component,src ,"out_DECOD_OUT_"+toString(i)+"_NO_EXECUTE"   ,
+                              dest,"out_DECOD_"    +toString(i)+"_NO_EXECUTE"   );
           PORT_MAP(_component,src ,"out_DECOD_OUT_"+toString(i)+"_IS_DELAY_SLOT",
                               dest,"out_DECOD_"    +toString(i)+"_IS_DELAY_SLOT");
 …
           PORT_MAP(_component,src ,"out_DECOD_OUT_"+toString(i)+"_EXCEPTION_USE",
                               dest,"out_DECOD_"    +toString(i)+"_EXCEPTION_USE");
+        }
+      if (_param->_have_port_depth)
+          PORT_MAP(_component,src ,"out_DECOD_OUT_"+toString(i)+"_EXCEPTION"    ,
+                              dest,"out_DECOD_"    +toString(i)+"_EXCEPTION"    );
+        }
       for (uint32_t i=0; i<_param->_nb_context; i++)
+        {
 …
 #endif
+          PORT_MAP(_component,src , "in_DEPTH_"+toString(i)+"_TAIL"     ,
+                              dest, "in_DEPTH_"+toString(i)+"_TAIL"     );
+          PORT_MAP(_component,src , "in_DEPTH_"+toString(i)+"_NB_BRANCH",
+                              dest, "in_DEPTH_"+toString(i)+"_NB_BRANCH");
+          if (_param->_have_port_depth)
+          PORT_MAP(_component,src , "in_DEPTH_"+toString(i)+"_MIN",
+                              dest, "in_DEPTH_"+toString(i)+"_MIN");
+          PORT_MAP(_component,src , "in_DEPTH_"+toString(i)+"_MAX",
+                              dest, "in_DEPTH_"+toString(i)+"_MAX");
+        }
 …
+    }
     // ~~~~~[ Others ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (DEBUG_Decod_unit == true)
+#if DEBUG_Decod_unit == true
       _component->test_map();
+#endif
 #ifdef POSITION
     if (usage_is_set(_usage,USE_POSITION))

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/src/Decod_unit_deallocation.cpp

-              r83
+              r88
         delete    in_NRESET;
         DELETE2_SIGNAL( in_IFETCH_VAL                         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1],1);
         DELETE2_SIGNAL(out_IFETCH_ACK                         ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1],1);
         DELETE2_SIGNAL( in_IFETCH_INSTRUCTION                 ,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1],_param->_size_instruction);
+        DELETE2_SIGNAL( in_IFETCH_VAL                         ,_param->_nb_context, _param->_nb_inst_fetch[it1],1);
+        DELETE2_SIGNAL(out_IFETCH_ACK                         ,_param->_nb_context, _param->_nb_inst_fetch[it1],1);
+        DELETE2_SIGNAL( in_IFETCH_INSTRUCTION                 ,_param->_nb_context, _param->_nb_inst_fetch[it1],_param->_size_instruction);
+        DELETE1_SIGNAL(in_IFETCH_CONTEXT_ID                   ,_param->_nb_context,_param->_size_context_id              );
+        DELETE1_SIGNAL(in_IFETCH_ADDRESS                      ,_param->_nb_context,_param->_size_general_data            );
+//      DELETE1_SIGNAL(in_IFETCH_ADDRESS_NEXT                 ,_param->_nb_context,_param->_size_general_data            );
+        DELETE1_SIGNAL(in_IFETCH_INST_IFETCH_PTR              ,_param->_nb_context,_param->_size_inst_ifetch_ptr         );
+        DELETE1_SIGNAL(in_IFETCH_BRANCH_STATE                 ,_param->_nb_context,_param->_size_branch_state            );
+        DELETE1_SIGNAL(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID  ,_param->_nb_context,_param->_size_branch_update_prediction);
+        DELETE1_SIGNAL(in_IFETCH_CONTEXT_ID                   ,_param->_nb_context,_param->_size_context_id      );
+        DELETE1_SIGNAL(in_IFETCH_ADDRESS                      ,_param->_nb_context,_param->_size_general_data    );
+//      DELETE1_SIGNAL(in_IFETCH_ADDRESS_NEXT                 ,_param->_nb_context,_param->_size_general_data    );
+        DELETE1_SIGNAL(in_IFETCH_INST_IFETCH_PTR              ,_param->_nb_context,_param->_size_inst_ifetch_ptr );
+        DELETE1_SIGNAL(in_IFETCH_BRANCH_STATE                 ,_param->_nb_context,_param->_size_branch_state    );
+        DELETE1_SIGNAL(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID  ,_param->_nb_context,_param->_size_depth           );
+        DELETE1_SIGNAL(in_IFETCH_EXCEPTION                    ,_param->_nb_context,_param->_size_exception_ifetch);
         DELETE1_SIGNAL(out_DECOD_VAL                          ,_param->_nb_inst_decod,1);
 …
         DELETE1_SIGNAL(out_DECOD_TYPE                         ,_param->_nb_inst_decod,_param->_size_type                  );
         DELETE1_SIGNAL(out_DECOD_OPERATION                    ,_param->_nb_inst_decod,_param->_size_operation             );
+        DELETE1_SIGNAL(out_DECOD_NO_EXECUTE                   ,_param->_nb_inst_decod,1                                   );
         DELETE1_SIGNAL(out_DECOD_IS_DELAY_SLOT                ,_param->_nb_inst_decod,1                                   );
         DELETE1_SIGNAL(out_DECOD_ADDRESS                      ,_param->_nb_inst_decod,_param->_size_general_data          );
 …
         DELETE1_SIGNAL(out_DECOD_NUM_REG_RE                   ,_param->_nb_inst_decod,_param->_size_special_register_logic);
         DELETE1_SIGNAL(out_DECOD_EXCEPTION_USE                ,_param->_nb_inst_decod,_param->_size_exception_use         );
+        DELETE1_SIGNAL(out_DECOD_EXCEPTION                    ,_param->_nb_inst_decod,_param->_size_exception_decod       );
         DELETE1_SIGNAL(out_PREDICT_VAL                        ,_param->_nb_inst_decod,1);
         DELETE1_SIGNAL( in_PREDICT_ACK                        ,_param->_nb_inst_decod,1);
         DELETE1_SIGNAL(out_PREDICT_CONTEXT_ID                 ,_param->_nb_inst_decod,_param->_size_context_id              );
         DELETE1_SIGNAL(out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod,1                                     );
         DELETE1_SIGNAL(out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod,_param->_size_branch_state            );
         DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod,_param->_size_branch_update_prediction);
         DELETE1_SIGNAL(out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod,_param->_size_branch_condition        );
 //      DELETE1_SIGNAL(out_PREDICT_BRANCH_STACK_WRITE         ,_param->_nb_inst_decod,1                                     );
         DELETE1_SIGNAL(out_PREDICT_BRANCH_DIRECTION           ,_param->_nb_inst_decod,1                                     );
         DELETE1_SIGNAL(out_PREDICT_ADDRESS_SRC                ,_param->_nb_inst_decod,_param->_size_general_data            );
         DELETE1_SIGNAL(out_PREDICT_ADDRESS_DEST               ,_param->_nb_inst_decod,_param->_size_general_data            );
 //      DELETE1_SIGNAL( in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod,1                                     );
+        DELETE1_SIGNAL(out_PREDICT_CONTEXT_ID                 ,_param->_nb_inst_decod,_param->_size_context_id      );
+        DELETE1_SIGNAL(out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod,_param->_size_branch_state    );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod,_param->_size_depth           );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod,_param->_size_branch_condition);
+//      DELETE1_SIGNAL(out_PREDICT_BRANCH_STACK_WRITE         ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_DIRECTION           ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL(out_PREDICT_ADDRESS_SRC                ,_param->_nb_inst_decod,_param->_size_general_data    );
+        DELETE1_SIGNAL(out_PREDICT_ADDRESS_DEST               ,_param->_nb_inst_decod,_param->_size_general_data    );
+//      DELETE1_SIGNAL( in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod,1                             );
+        DELETE1_SIGNAL( in_DEPTH_TAIL                         ,_param->_nb_context,_param->_size_depth  );
+        if (_param->_have_port_depth)
+        DELETE1_SIGNAL( in_DEPTH_NB_BRANCH                    ,_param->_nb_context,_param->_size_depth+1);
+        DELETE1_SIGNAL( in_DEPTH_MIN                          ,_param->_nb_context,_param->_size_depth  );
+        DELETE1_SIGNAL( in_DEPTH_MAX                          ,_param->_nb_context,_param->_size_depth+1);
         DELETE1_SIGNAL(out_NB_INST_DECOD_ALL                  ,_param->_nb_context,_param->_size_nb_inst_decod+1);
+        DELETE1_SIGNAL(out_NB_INST_DECOD_ALL                  ,_param->_nb_context,_param->_size_nb_inst_decod);
         DELETE1_SIGNAL(in_CONTEXT_DECOD_ENABLE                ,_param->_nb_context,1);
 …
         DELETE_SIGNAL( in_CONTEXT_EVENT_ACK                   ,1);
         DELETE_SIGNAL(out_CONTEXT_EVENT_CONTEXT_ID            ,_param->_size_context_id  );
+        DELETE_SIGNAL(out_CONTEXT_EVENT_DEPTH                 ,_param->_size_depth       );
         DELETE_SIGNAL(out_CONTEXT_EVENT_TYPE                  ,_param->_size_event_type  );
         DELETE_SIGNAL(out_CONTEXT_EVENT_IS_DELAY_SLOT         ,1                         );

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/src/Parameters.cpp

-              r87
+              r88
                           uint32_t            size_general_data            ,
                           uint32_t          * nb_branch_speculated         ,
                           uint32_t            size_branch_update_prediction,
+//                        uint32_t          * size_branch_update_prediction,
                           uint32_t            nb_context_select            ,
                           Tpriority_t         select_priority              ,
                           Tload_balancing_t   select_load_balancing        ,
                           bool             ** instruction_implemeted       ,
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t))
+                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
+                          bool                is_toplevel
+                          )
+  {
     log_begin(Decod_unit,FUNCTION);
 …
     _nb_inst_decod                 = nb_inst_decod                ;
     _size_queue                    = size_queue                   ;
     _size_general_data             = size_general_data            ;
+//  _size_general_data             = size_general_data            ;
     _nb_branch_speculated          = nb_branch_speculated         ;
     _size_branch_update_prediction = size_branch_update_prediction;
+//  _size_branch_update_prediction = size_branch_update_prediction;
     _nb_context_select             = nb_context_select            ;
     _select_priority               = select_priority              ;
 …
     _max_nb_inst_fetch                     = max<uint32_t>(_nb_inst_fetch,_nb_context);
+//  _size_address_inst                     = size_general_data-2;
-    _size_address_inst                     = size_general_data-2;
-    _size_context_id                       = log2(nb_context          );
-    _size_depth                            = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
-    _size_inst_ifetch_ptr                  = log2(_max_nb_inst_fetch  );
-    _have_port_context_id                  = (_size_context_id > 0);
-    _have_port_depth                       = (_size_depth      > 0);
-    _have_port_branch_update_prediction_id = (_size_branch_update_prediction > 0);
-    _have_port_inst_ifetch_ptr             = (_size_inst_ifetch_ptr > 0);
     test();
 …
        _nb_inst_fetch                ,
        _nb_inst_decod                ,
        max<uint32_t>(_nb_branch_speculated,_nb_context),
        _size_branch_update_prediction,
+       _nb_branch_speculated,
+//     _size_branch_update_prediction,
        _nb_context_select            ,
        _size_general_data            ,
+        size_general_data            ,
        _select_priority              ,
        _select_load_balancing        ,
 …
        _nb_inst_decod       ,
        _size_queue          ,
        _size_general_data   ,
+        size_general_data   ,
        _nb_branch_speculated);
+    _size_nb_inst_decod = _param_decod_queue->_size_nb_inst;
+    if (is_toplevel)
+      {
+        _size_context_id                       = log2(_nb_context);
+        _size_depth                            = max<uint32_t>(_nb_branch_speculated,_nb_context);
+//      _size_branch_update_prediction_id      = max<uint32_t>(_size_branch_update_prediction,_nb_context);
+        _size_inst_ifetch_ptr                  = log2(max<uint32_t>(_nb_inst_fetch,_nb_context));
+        _size_nb_inst_decod                    = log2(_size_queue)+1;
+        _size_instruction_address              = size_general_data-2;
+        _size_general_data                     = size_general_data;
+        _have_port_context_id                  = _size_context_id > 0;
+        _have_port_depth                       = (_size_depth                       > 0);
+//      _have_port_branch_update_prediction_id = (_size_branch_update_prediction_id > 0);
+        _have_port_inst_ifetch_ptr             = (_size_inst_ifetch_ptr             > 0);
+        copy ();
+      }
     log_end(Decod_unit,FUNCTION);
   };
 …
     log_begin(Decod_unit,FUNCTION);
+    delete _param_decod;
+    delete _param_decod_queue;
+    delete    _param_decod;
+    delete    _param_decod_queue;
+    log_end(Decod_unit,FUNCTION);
+  };
+#undef  FUNCTION
+#define FUNCTION "Decod_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_begin(Decod_unit,FUNCTION);
+    COPY(_param_decod      );
+    COPY(_param_decod_queue);
     log_end(Decod_unit,FUNCTION);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/src/Parameters_print.cpp

-              r83
+              r88
     xml.singleton_begin("size_queue                   "); xml.attribut("value",toString(_size_queue                   )); xml.singleton_end();
     xml.singleton_begin("size_general_data            "); xml.attribut("value",toString(_size_general_data            )); xml.singleton_end();
-    xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
     xml.singleton_begin("nb_context_select            "); xml.attribut("value",toString(_nb_context_select            )); xml.singleton_end();
     xml.singleton_begin("select_priority              "); xml.attribut("value",toString(_select_priority              )); xml.singleton_end();
 …
         xml.  singleton_begin("nb_inst_fetch                "); xml.attribut("value",toString(_nb_inst_fetch                [i])); xml.singleton_end();
         xml.  singleton_begin("nb_branch_speculated         "); xml.attribut("value",toString(_nb_branch_speculated         [i])); xml.singleton_end();
+//      xml.  singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction[i])); xml.singleton_end();
         xml. balise_close();
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/SelfTest/Makefile

r81	r88
24	24	library_clean : Address_management_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/SelfTest/src/main.cpp

-              r81
+              r88
         (_nb_instruction               ,
          _size_address                 ,
+         _size_branch_update_prediction);
+         _size_branch_update_prediction,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/SelfTest/src/test.cpp

-              r84
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Address_management * _Address_management = new Address_management
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC_SC_SIGNAL (out_EVENT_ACK                          ,"out_EVENT_ACK                          ",Tcontrol_t        );
   ALLOC_SC_SIGNAL ( in_EVENT_ADDRESS                      ," in_EVENT_ADDRESS                      ",Tgeneral_address_t);
+  ALLOC_SC_SIGNAL ( in_EVENT_ADDRESS_NEXT                 ," in_EVENT_ADDRESS_NEXT                 ",Tgeneral_address_t);
+  ALLOC_SC_SIGNAL ( in_EVENT_ADDRESS_NEXT_VAL             ," in_EVENT_ADDRESS_NEXT_VAL             ",Tcontrol_t        );
+  ALLOC_SC_SIGNAL ( in_EVENT_IS_DS_TAKE                   ," in_EVENT_IS_DS_TAKE                   ",Tcontrol_t        );
   /********************************************************
 …
   INSTANCE_SC_SIGNAL (_Address_management,out_ADDRESS_INSTRUCTION_ADDRESS        );
   INSTANCE1_SC_SIGNAL(_Address_management,out_ADDRESS_INSTRUCTION_ENABLE         ,_param->_nb_instruction);
   if (_param->_have_port_instruction_ptr)
+  if (_param->_have_port_inst_ifetch_ptr)
   INSTANCE_SC_SIGNAL (_Address_management,out_ADDRESS_INST_IFETCH_PTR            );
   INSTANCE_SC_SIGNAL (_Address_management,out_ADDRESS_BRANCH_STATE               );
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE_SC_SIGNAL (_Address_management,out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID);
   INSTANCE_SC_SIGNAL (_Address_management,out_PREDICT_VAL                        );
 …
   INSTANCE_SC_SIGNAL (_Address_management, in_PREDICT_PC_NEXT_IS_DS_TAKE         );
   INSTANCE1_SC_SIGNAL(_Address_management, in_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_instruction);
   if (_param->_have_port_instruction_ptr)
+  if (_param->_have_port_inst_ifetch_ptr)
   INSTANCE_SC_SIGNAL (_Address_management, in_PREDICT_INST_IFETCH_PTR            );
   INSTANCE_SC_SIGNAL (_Address_management, in_PREDICT_BRANCH_STATE               );
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE_SC_SIGNAL (_Address_management, in_PREDICT_BRANCH_UPDATE_PREDICTION_ID);
   INSTANCE_SC_SIGNAL (_Address_management, in_EVENT_VAL                          );
   INSTANCE_SC_SIGNAL (_Address_management,out_EVENT_ACK                          );
   INSTANCE_SC_SIGNAL (_Address_management, in_EVENT_ADDRESS                      );
+  INSTANCE_SC_SIGNAL (_Address_management, in_EVENT_ADDRESS_NEXT                 );
+  INSTANCE_SC_SIGNAL (_Address_management, in_EVENT_ADDRESS_NEXT_VAL             );
+  INSTANCE_SC_SIGNAL (_Address_management, in_EVENT_IS_DS_TAKE                   );
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
   Tcontrol_t      nn_val  = false;
   Tgeneral_data_t c_addr  = 0x100;
   Tgeneral_data_t n_addr  = 0x100;
   Tgeneral_data_t nn_addr = 0x100;
+  Tgeneral_data_t c_addr  = 0x100>>2;
+  Tgeneral_data_t n_addr  = 0x100>>2;
+  Tgeneral_data_t nn_addr = 0x100>>2;
   Tcontrol_t      c_enable [_param->_nb_instruction];
 …
   LABEL("Send Reset");
+  do
+    {
+      in_EVENT_VAL    ->write(1);
+      in_EVENT_ADDRESS->write(n_addr);
+      SC_START(1);
+    } while (out_EVENT_ACK->read() == false);
+  in_EVENT_VAL    ->write(0);
+//   do
+//     {
+//       in_EVENT_VAL             ->write(1);
+//       in_EVENT_ADDRESS         ->write(n_addr);
+//       in_EVENT_ADDRESS_NEXT    ->write(nn_addr);
+//       in_EVENT_ADDRESS_NEXT_VAL->write(0);
+//       in_EVENT_IS_DS_TAKE      ->write(0);
+//       SC_START(1);
+//     } while (out_EVENT_ACK->read() == false);
+//   in_EVENT_VAL    ->write(0);
   n_val = 1;
 …
+      }
+      in_EVENT_VAL    ->write((rand()%100)<percent_transaction_event  );
+      in_EVENT_ADDRESS->write(0x100);
+      in_EVENT_VAL             ->write((rand()%100)<percent_transaction_event  );
+      in_EVENT_ADDRESS         ->write(0x77);
+      in_EVENT_ADDRESS_NEXT    ->write(0x171);
+      Tcontrol_t next_val = rand()%2;
+      in_EVENT_ADDRESS_NEXT_VAL->write(next_val);
+      in_EVENT_IS_DS_TAKE      ->write(next_val);
       //-------------------------------------------------
 …
           for (uint32_t i=0; i<_param->_nb_instruction; i++)
           TEST(Tcontrol_t        ,out_ADDRESS_INSTRUCTION_ENABLE     [i] ->read(),c_enable[i]);
           if (_param->_have_port_instruction_ptr)
+          if (_param->_have_port_inst_ifetch_ptr)
           TEST(Tinst_ifetch_ptr_t,out_ADDRESS_INST_IFETCH_PTR            ->read(),0);
           TEST(Tbranch_state_t   ,out_ADDRESS_BRANCH_STATE               ->read(),0);
           if (_param->_have_port_branch_update_prediction_id)
+          if (_param->_have_port_depth)
           TEST(Tprediction_ptr_t ,out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID->read(),0);
 …
           LABEL("EVENT      : Transaction accepted");
+          c_val           = false;
+          n_val           = true;
+          nn_val          = false;
+          n_addr         = in_EVENT_ADDRESS->read();
+          n_is_ds_take   = 0;
+          c_val        = false;
+          n_val        = true;
+          n_addr       = in_EVENT_ADDRESS         ->read();
+          n_is_ds_take = in_EVENT_IS_DS_TAKE      ->read();
+          nn_val       = in_EVENT_ADDRESS_NEXT_VAL->read();
+          nn_addr      = in_EVENT_ADDRESS_NEXT    ->read();
+          nn_is_ds_take= false;
+//           nn_val = false;
+//           n_is_ds_take = 0;
           n_enable [0] = 1;
           for (uint32_t i=1; i<_param->_nb_instruction; i++)
             n_enable [i] = 0;
+          for (uint32_t i=1; i<_param->_nb_instruction; i++)
+            n_enable [i] = 0;
+        }
 …
   delete    out_EVENT_ACK                          ;
   delete     in_EVENT_ADDRESS                      ;
+  delete     in_EVENT_ADDRESS_NEXT                 ;
+  delete     in_EVENT_ADDRESS_NEXT_VAL             ;
+  delete     in_EVENT_IS_DS_TAKE                   ;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/include/Address_management.h

-              r84
+              r88
   public    : SC_OUT(Tcontrol_t        )    * out_EVENT_ACK                           ;
   public    : SC_IN (Tgeneral_address_t)    *  in_EVENT_ADDRESS                       ;
+  public    : SC_IN (Tgeneral_address_t)    *  in_EVENT_ADDRESS_NEXT                  ;
+  public    : SC_IN (Tcontrol_t        )    *  in_EVENT_ADDRESS_NEXT_VAL              ;
+  public    : SC_IN (Tcontrol_t        )    *  in_EVENT_IS_DS_TAKE                    ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/include/Parameters.h

-              r81
+              r88
     //-----[ fields ]------------------------------------------------------------
   public : uint32_t _nb_instruction               ;
   public : uint32_t _size_address                 ;
   public : uint32_t _size_branch_update_prediction;
+//public : uint32_t _size_address                 ;
+//public : uint32_t _size_branch_update_prediction;
   public : uint32_t _size_instruction_ptr                 ;
   public : bool     _have_port_instruction_ptr            ;
   public : bool     _have_port_branch_update_prediction_id;
+//public : uint32_t _size_instruction_ptr                 ;
+//
+//public : bool     _have_port_instruction_ptr            ;
+//public : bool     _have_port_branch_update_prediction_id;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t nb_instruction,
                         uint32_t size_address  ,
+                        uint32_t size_branch_update_prediction);
+                        uint32_t size_branch_update_prediction,
+                        bool     is_toplevel=false);
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Address_management.cpp

-              r81
+              r88
     log_printf(FUNC,Address_management,FUNCTION,"Begin");
+#if DEBUG_Address_management == true
+    log_printf(INFO,Address_management,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Address_management,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Address_management,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         // Affect output constant
 …
 #endif
+      }
     log_printf(FUNC,Address_management,FUNCTION,"End");
   };
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Address_management_allocation.cpp

-              r81
+              r88
       ALLOC_VALACK_OUT (out_ADDRESS_VAL                        ,VAL);
       ALLOC_VALACK_IN  ( in_ADDRESS_ACK                        ,ACK);
       ALLOC_SIGNAL_OUT (out_ADDRESS_INSTRUCTION_ADDRESS        ,"instruction_address"        ,Tgeneral_address_t,_param->_size_address                 );
       ALLOC_SIGNAL_OUT (out_ADDRESS_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_instruction_ptr         );
+      ALLOC_SIGNAL_OUT (out_ADDRESS_INSTRUCTION_ADDRESS        ,"instruction_address"        ,Tgeneral_address_t,_param->_size_instruction_address     );
+      ALLOC_SIGNAL_OUT (out_ADDRESS_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_inst_ifetch_ptr         );
       ALLOC_SIGNAL_OUT (out_ADDRESS_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t   ,_param->_size_branch_state            );
       ALLOC_SIGNAL_OUT (out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_branch_update_prediction);
+      ALLOC_SIGNAL_OUT (out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_depth);
+    }
 …
       ALLOC_VALACK_OUT (out_PREDICT_VAL                        ,VAL);
       ALLOC_VALACK_IN  ( in_PREDICT_ACK                        ,ACK);
       ALLOC_SIGNAL_OUT (out_PREDICT_PC_PREVIOUS                ,"pc_previous"                ,Tgeneral_address_t,_param->_size_address);
       ALLOC_SIGNAL_OUT (out_PREDICT_PC_CURRENT                 ,"pc_current"                 ,Tgeneral_address_t,_param->_size_address);
+      ALLOC_SIGNAL_OUT (out_PREDICT_PC_PREVIOUS                ,"pc_previous"                ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_OUT (out_PREDICT_PC_CURRENT                 ,"pc_current"                 ,Tgeneral_address_t,_param->_size_instruction_address);
       ALLOC_SIGNAL_OUT (out_PREDICT_PC_CURRENT_IS_DS_TAKE      ,"pc_current_is_ds_take"      ,Tcontrol_t        ,1);
       ALLOC_SIGNAL_IN  ( in_PREDICT_PC_NEXT                    ,"pc_next"                    ,Tgeneral_address_t,_param->_size_address);
+      ALLOC_SIGNAL_IN  ( in_PREDICT_PC_NEXT                    ,"pc_next"                    ,Tgeneral_address_t,_param->_size_instruction_address);
       ALLOC_SIGNAL_IN  ( in_PREDICT_PC_NEXT_IS_DS_TAKE         ,"pc_next_is_ds_take"         ,Tcontrol_t        ,1);
       ALLOC_SIGNAL_IN  ( in_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_instruction_ptr);
+      ALLOC_SIGNAL_IN  ( in_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_inst_ifetch_ptr);
       ALLOC_SIGNAL_IN  ( in_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t   ,_param->_size_branch_state);
       ALLOC_SIGNAL_IN  ( in_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_branch_update_prediction);
+      ALLOC_SIGNAL_IN  ( in_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_depth);
+    }
+    {
 …
       ALLOC_INTERFACE("event", IN, SOUTH, "Event (miss, exception ...)");
+      ALLOC_VALACK_IN ( in_EVENT_VAL    ,VAL);
+      ALLOC_VALACK_OUT(out_EVENT_ACK    ,ACK);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS,"address",Tgeneral_address_t,_param->_size_address);
+      ALLOC_VALACK_IN ( in_EVENT_VAL          ,VAL);
+      ALLOC_VALACK_OUT(out_EVENT_ACK          ,ACK);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS         ,"address"         ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS_NEXT    ,"address_next"    ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS_NEXT_VAL,"address_next_val",Tcontrol_t,1);
+      ALLOC_SIGNAL_IN ( in_EVENT_IS_DS_TAKE      ,"is_ds_take"      ,Tcontrol_t,1);
+    }
+    // ~~~~~[ Internal  ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        reg_PC_CURRENT_INSTRUCTION_ENABLE = new Tcontrol_t [_param->_nb_instruction];
+        reg_PC_NEXT_INSTRUCTION_ENABLE    = new Tcontrol_t [_param->_nb_instruction];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    reg_PC_CURRENT_INSTRUCTION_ENABLE = new Tcontrol_t [_param->_nb_instruction];
-    reg_PC_NEXT_INSTRUCTION_ENABLE    = new Tcontrol_t [_param->_nb_instruction];
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Address_management_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Address_management,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         delete    out_ADDRESS_INSTRUCTION_ADDRESS        ;
         delete [] out_ADDRESS_INSTRUCTION_ENABLE         ;
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         delete    out_ADDRESS_INST_IFETCH_PTR            ;
         delete    out_ADDRESS_BRANCH_STATE               ;
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         delete    out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID;
         delete    out_PREDICT_VAL                        ;
 …
         delete     in_PREDICT_PC_NEXT_IS_DS_TAKE         ;
         delete []  in_PREDICT_INSTRUCTION_ENABLE         ;
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         delete     in_PREDICT_INST_IFETCH_PTR            ;
         delete     in_PREDICT_BRANCH_STATE               ;
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         delete     in_PREDICT_BRANCH_UPDATE_PREDICTION_ID;
         delete     in_EVENT_VAL                          ;
         delete    out_EVENT_ACK                          ;
         delete     in_EVENT_ADDRESS                      ;
+        delete     in_EVENT_ADDRESS_NEXT                 ;
+        delete     in_EVENT_ADDRESS_NEXT_VAL             ;
+        delete     in_EVENT_IS_DS_TAKE                   ;
+        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        if (usage_is_set(_usage,USE_SYSTEMC))
+          {
+            delete reg_PC_CURRENT_INSTRUCTION_ENABLE;
+            delete reg_PC_NEXT_INSTRUCTION_ENABLE   ;
+          }
+      }
-    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete reg_PC_CURRENT_INSTRUCTION_ENABLE;
-    delete reg_PC_NEXT_INSTRUCTION_ENABLE   ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Address_management_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Address_management_genMoore.cpp

-              r84
+              r88
     PORT_WRITE(out_ADDRESS_VAL                        ,internal_ADDRESS_VAL                      );
     PORT_WRITE(out_ADDRESS_INSTRUCTION_ADDRESS        ,reg_PC_CURRENT                            );
     if (_param->_have_port_instruction_ptr)
+    if (_param->_have_port_inst_ifetch_ptr)
     PORT_WRITE(out_ADDRESS_INST_IFETCH_PTR            ,reg_PC_CURRENT_INST_IFETCH_PTR            );
     PORT_WRITE(out_ADDRESS_BRANCH_STATE               ,reg_PC_CURRENT_BRANCH_STATE               );
     if (_param->_have_port_branch_update_prediction_id)
+    if (_param->_have_port_depth)
     PORT_WRITE(out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID,reg_PC_CURRENT_BRANCH_UPDATE_PREDICTION_ID);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Address_management_transition.cpp

-              r84
+              r88
   void Address_management::transition (void)
+  {
+    log_printf(FUNC,Address_management,FUNCTION,"Begin");
+    log_begin(Address_management,FUNCTION);
+    log_function(Address_management,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
         // nothing is valid
         reg_PC_CURRENT_VAL   = 0;
+        reg_PC_NEXT_VAL      = 0;
+        reg_PC_NEXT_VAL      = 1;
+        reg_PC_NEXT          = 0x100>>2;
         reg_PC_NEXT_NEXT_VAL = 0;
+      }
 …
             for (uint32_t i=0; i<_param->_nb_instruction; i++)
             reg_PC_NEXT_INSTRUCTION_ENABLE [i] = PORT_READ(in_PREDICT_INSTRUCTION_ENABLE [i]);
             if (_param->_have_port_instruction_ptr)
+            if (_param->_have_port_inst_ifetch_ptr)
             reg_PC_NEXT_INST_IFETCH_PTR             = PORT_READ(in_PREDICT_INST_IFETCH_PTR            );
             reg_PC_NEXT_BRANCH_STATE                = PORT_READ(in_PREDICT_BRANCH_STATE               );
             if (_param->_have_port_branch_update_prediction_id)
+            if (_param->_have_port_depth)
             reg_PC_NEXT_BRANCH_UPDATE_PREDICTION_ID = PORT_READ(in_PREDICT_BRANCH_UPDATE_PREDICTION_ID);
 …
 #ifdef STATISTICS
+            (*_stat_nb_transaction_predict) ++;
+            if (usage_is_set(_usage,USE_STATISTICS))
+              (*_stat_nb_transaction_predict) ++;
 #endif
+          }
 …
+          {
 #ifdef STATISTICS
+            if (reg_PC_CURRENT_VAL)
+              {
+                (*_stat_nb_transaction_address) ++;
+                for (uint32_t i=0; i<_param->_nb_instruction; i++)
+                  if (reg_PC_CURRENT_INSTRUCTION_ENABLE [i] == true)
+                    (*_stat_sum_packet_size) ++;
+              }
+            if (usage_is_set(_usage,USE_STATISTICS))
+              if (reg_PC_CURRENT_VAL)
+                {
+                  (*_stat_nb_transaction_address) ++;
+                  for (uint32_t i=0; i<_param->_nb_instruction; i++)
+                    if (reg_PC_CURRENT_INSTRUCTION_ENABLE [i] == true)
+                      (*_stat_sum_packet_size) ++;
+                }
 #endif
 …
         if (PORT_READ(in_EVENT_VAL) and internal_EVENT_ACK)
+          {
+            log_printf(TRACE,Address_management,FUNCTION,"EVENT : Transaction");
+            log_printf(TRACE,Address_management,FUNCTION,"  * EVENT : Transaction");
+            log_printf(TRACE,Address_management,FUNCTION,"    * IS_DS_TAKE       : %d"  ,PORT_READ(in_EVENT_IS_DS_TAKE      ));
+            log_printf(TRACE,Address_management,FUNCTION,"    * ADDRESS          : %.8x (%.8x)",PORT_READ(in_EVENT_ADDRESS         ),PORT_READ(in_EVENT_ADDRESS         )<<2);
+            log_printf(TRACE,Address_management,FUNCTION,"    * ADDRESS_NEXT     : %.8x (%.8x)",PORT_READ(in_EVENT_ADDRESS_NEXT    ),PORT_READ(in_EVENT_ADDRESS_NEXT    )<<2);
+            log_printf(TRACE,Address_management,FUNCTION,"    * ADDRESS_NEXT_VAL : %d"  ,PORT_READ(in_EVENT_ADDRESS_NEXT_VAL));
             reg_PC_CURRENT_VAL                      = 0;
             reg_PC_NEXT_VAL                         = 1;
 …
             //  * load   miss speculation : the load is execute, the event_address is the next address (also the destination of branch)
             //  * exception               : goto the first instruction of exception handler (also is not in delay slot).
+            reg_PC_NEXT_IS_DS_TAKE                  = 0;
+            reg_PC_NEXT_IS_DS_TAKE                  = PORT_READ(in_EVENT_IS_DS_TAKE);
 //          reg_PC_NEXT_INST_IFETCH_PTR             = 0;
 //          reg_PC_NEXT_BRANCH_STATE                = BRANCH_STATE_NONE;
 //          reg_PC_NEXT_BRANCH_UPDATE_PREDICTION_ID = 0;
 //          reg_PC_NEXT_INSTRUCTION_ENABLE [0]      = 1; // only the instruction at the event address is valid, because we have no information on the branch presence in the instruction bundle.
 //          for (uint32_t i=1; i<_param->_nb_instruction; i++)
 //            reg_PC_NEXT_INSTRUCTION_ENABLE [i] = 0;
+            reg_PC_NEXT_INSTRUCTION_ENABLE [0]      = 1; // only the instruction at the event address is valid, because we have no information on the branch presence in the instruction bundle.
+            for (uint32_t i=1; i<_param->_nb_instruction; i++)
+              reg_PC_NEXT_INSTRUCTION_ENABLE [i] = 0;
+            reg_PC_NEXT_NEXT_VAL                    = 0; // cancel all prediction (event is send at the predict unit)
+            reg_PC_NEXT_NEXT_VAL                    = PORT_READ(in_EVENT_ADDRESS_NEXT_VAL);
+            reg_PC_NEXT_NEXT                        = PORT_READ(in_EVENT_ADDRESS_NEXT);
+            reg_PC_NEXT_NEXT_IS_DS_TAKE             = 0;//??
+            // Note : is_ds_take = address_next_val
+            // Because, is not ds take, can continue in sequence
+#ifdef DEBUG_TEST
+            if (PORT_READ(in_EVENT_ADDRESS_NEXT_VAL) and not PORT_READ(in_EVENT_IS_DS_TAKE))
+              throw ERRORMORPHEO(FUNCTION,_("Event : address_next_next_val but next is not a ds take"));
+#endif
 #ifdef STATISTICS
+            (*_stat_nb_transaction_event) ++;
+            if (usage_is_set(_usage,USE_STATISTICS))
+              (*_stat_nb_transaction_event) ++;
 #endif
+          }
+      }
 #if DEBUG >= DEBUG_TRACE
     log_printf(TRACE,Address_management,FUNCTION,"Address_Management : ");
     log_printf(TRACE,Address_management,FUNCTION,"Current   : %d %d 0x%x",reg_PC_CURRENT_VAL, reg_PC_CURRENT_IS_DS_TAKE, reg_PC_CURRENT);
     log_printf(TRACE,Address_management,FUNCTION,"Next      : %d %d 0x%x",reg_PC_NEXT_VAL, reg_PC_NEXT_IS_DS_TAKE, reg_PC_NEXT);
     log_printf(TRACE,Address_management,FUNCTION,"Next_Next : %d %d 0x%x",reg_PC_NEXT_NEXT_VAL, reg_PC_NEXT_NEXT_IS_DS_TAKE, reg_PC_NEXT_NEXT);
+#if defined(DEBUG) and (DEBUG >= DEBUG_TRACE)
+    log_printf(TRACE,Address_management,FUNCTION,"  * Dump PC");
+    log_printf(TRACE,Address_management,FUNCTION,"    * Current   : %d %d 0x%.8x (%.8x)",reg_PC_CURRENT_VAL  , reg_PC_CURRENT_IS_DS_TAKE  , reg_PC_CURRENT  , reg_PC_CURRENT  <<2);
+    log_printf(TRACE,Address_management,FUNCTION,"    * Next      : %d %d 0x%.8x (%.8x)",reg_PC_NEXT_VAL     , reg_PC_NEXT_IS_DS_TAKE     , reg_PC_NEXT     , reg_PC_NEXT     <<2);
+    log_printf(TRACE,Address_management,FUNCTION,"    * Next_Next : %d %d 0x%.8x (%.8x)",reg_PC_NEXT_NEXT_VAL, reg_PC_NEXT_NEXT_IS_DS_TAKE, reg_PC_NEXT_NEXT, reg_PC_NEXT_NEXT<<2);
 #endif
 …
     end_cycle ();
 #endif
     log_printf(FUNC,Address_management,FUNCTION,"End");
+    log_end(Address_management,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Parameters.cpp

-              r81
+              r88
   Parameters::Parameters (uint32_t nb_instruction,
                           uint32_t size_address  ,
+                          uint32_t size_branch_update_prediction)
+                          uint32_t size_branch_update_prediction,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Address_management,FUNCTION,"Begin");
+    _nb_instruction                        = nb_instruction               ;
+    _size_address                          = size_address                 ;
+    _size_branch_update_prediction         = size_branch_update_prediction;
+    _size_instruction_ptr                  = log2(nb_instruction);
+    _have_port_instruction_ptr             = _size_instruction_ptr > 0;
+    _have_port_branch_update_prediction_id = size_branch_update_prediction > 0;
+    _nb_instruction = nb_instruction               ;
     test();
+    if (is_toplevel)
+      {
+        _size_instruction_address  = size_address                 ;
+        _size_depth                = size_branch_update_prediction;
+        _size_inst_ifetch_ptr      = log2(nb_instruction);
+        _have_port_inst_ifetch_ptr = _size_inst_ifetch_ptr > 0;
+        _have_port_depth           = _size_depth > 0;
+        copy();
+      }
     log_printf(FUNC,Address_management,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Address_management::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Address_management,FUNCTION,"Begin");
+    log_printf(FUNC,Address_management,FUNCTION,"End");
+  };
 }; // end namespace address_management
 }; // end namespace ifetch_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management/src/Parameters_print.cpp

-              r81
+              r88
     log_printf(FUNC,Address_management,FUNCTION,"Begin");
     XML xml ("address_management");
+//     XML xml ("address_management");
+    xml.balise_open("address_management");
+    xml.singleton_begin("nb_instruction               "); xml.attribut("value",toString(_nb_instruction               )); xml.singleton_end();
+    xml.singleton_begin("size_address                 "); xml.attribut("value",toString(_size_address                 )); xml.singleton_end();
+    xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
+    xml.balise_close();
+//     xml.balise_open("address_management");
+//     xml.singleton_begin("nb_instruction               "); xml.attribut("value",toString(_nb_instruction               )); xml.singleton_end();
+// //  xml.singleton_begin("size_address                 "); xml.attribut("value",toString(_size_address                 )); xml.singleton_end();
+// //  xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
+//     xml.balise_close();
+//     return xml.get_body(depth);
+    std::string str = "";
     log_printf(FUNC,Address_management,FUNCTION,"End");
     return xml.get_body(depth);
+    return str;
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/SelfTest/Makefile

r81	r88
24	24	library_clean : Ifetch_queue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_instruction                ,
          _size_branch_update_prediction ,
+         _size_general_data             );
+         _size_general_data             ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Ifetch_queue * _Ifetch_queue = new Ifetch_queue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ADDRESS_VAL                        );
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_ADDRESS_ACK                        );
   if (_param->_have_port_queue_ptr)
+  if (_param->_have_port_ifetch_queue_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_ADDRESS_IFETCH_QUEUE_ID            );
   INSTANCE1_SC_SIGNAL(_Ifetch_queue, in_ADDRESS_INSTRUCTION_ENABLE         ,_param->_nb_instruction);
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ADDRESS_INSTRUCTION_ADDRESS        );
   if (_param->_have_port_instruction_ptr)
+  if (_param->_have_port_inst_ifetch_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ADDRESS_INST_IFETCH_PTR            );
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ADDRESS_BRANCH_STATE               );
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID);
   INSTANCE1_SC_SIGNAL(_Ifetch_queue,out_DECOD_VAL                          ,_param->_nb_instruction);
 …
   INSTANCE1_SC_SIGNAL(_Ifetch_queue,out_DECOD_INSTRUCTION                  ,_param->_nb_instruction);
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_DECOD_ADDRESS                      );
   if (_param->_have_port_instruction_ptr)
+  if (_param->_have_port_inst_ifetch_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_DECOD_INST_IFETCH_PTR              );
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_DECOD_BRANCH_STATE                 );
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_DECOD_BRANCH_UPDATE_PREDICTION_ID  );
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_DECOD_EXCEPTION                    );
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ICACHE_RSP_VAL                     );
   INSTANCE_SC_SIGNAL (_Ifetch_queue,out_ICACHE_RSP_ACK                     );
   if (_param->_have_port_queue_ptr)
+  if (_param->_have_port_ifetch_queue_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_queue, in_ICACHE_RSP_PACKET_ID               );
   INSTANCE1_SC_SIGNAL(_Ifetch_queue, in_ICACHE_RSP_INSTRUCTION             ,_param->_nb_instruction);
 …
           for (uint32_t i=0; i<_param->_nb_instruction; i++)
           in_ADDRESS_INSTRUCTION_ENABLE [i]      ->write(i<=nb_inst_enable);
           if (_param->_have_port_instruction_ptr)
+          if (_param->_have_port_inst_ifetch_ptr)
           in_ADDRESS_INST_IFETCH_PTR             ->write(address%_param->_nb_instruction);
           in_ADDRESS_BRANCH_STATE                ->write(address%SIZE_BRANCH_STATE);
           if (_param->_have_port_branch_update_prediction_id)
           in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID ->write(address%_param->_size_branch_update_prediction);
+          if (_param->_have_port_depth)
+          in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID ->write(address%_param->_size_depth);
           // =====
 …
               list_wait_decod.push_back(address);
 //            list_req_icache.insert(, entry_t((_param->_have_port_queue_ptr)?out_ADDRESS_IFETCH_QUEUE_ID->read():0,address));
+//            list_req_icache.insert(, entry_t((_param->_have_port_ifetch_queue_ptr)?out_ADDRESS_IFETCH_QUEUE_ID->read():0,address));
               uint32_t cycle = ((rand()%100)<percent_icache_hit)?1:icache_miss_penality;
 …
               LABEL("  * list_req_icache : %d",list_req_icache.size());
               list_req_icache.insert(it,entry_t(cycle,(_param->_have_port_queue_ptr)?out_ADDRESS_IFETCH_QUEUE_ID->read():0,address));
+              list_req_icache.insert(it,entry_t(cycle,(_param->_have_port_ifetch_queue_ptr)?out_ADDRESS_IFETCH_QUEUE_ID->read():0,address));
               LABEL("  * list_req_icache : %d",list_req_icache.size());
               address += 4*_param->_nb_instruction;
 …
               TEST(Tgeneral_data_t   ,out_DECOD_ADDRESS                    ->read(), addr);
               TEST(Tbranch_state_t   ,out_DECOD_BRANCH_STATE               ->read(),addr%SIZE_BRANCH_STATE);
               if (_param->_have_port_instruction_ptr)
+              if (_param->_have_port_inst_ifetch_ptr)
               TEST(Tinst_ifetch_ptr_t,out_DECOD_INST_IFETCH_PTR            ->read(),addr%_param->_nb_instruction);
               if (_param->_have_port_branch_update_prediction_id)
               TEST(Tprediction_ptr_t ,out_DECOD_BRANCH_UPDATE_PREDICTION_ID->read(),addr%_param->_size_branch_update_prediction);
+              if (_param->_have_port_depth)
+              TEST(Tprediction_ptr_t ,out_DECOD_BRANCH_UPDATE_PREDICTION_ID->read(),addr%_param->_size_depth);
               if ((addr % modulo_iberr) == 0)
               TEST(Texception_t      ,out_DECOD_EXCEPTION                  ->read(),EXCEPTION_IFETCH_BUS_ERROR);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/include/Parameters.h

-              r81
+              r88
   public : uint32_t _size_queue                           ;
   public : uint32_t _nb_instruction                       ;
   public : uint32_t _size_branch_update_prediction        ;
   public : uint32_t _size_general_data                    ;
+//public : uint32_t _size_branch_update_prediction        ;
+//public : uint32_t _size_general_data                    ;
   public : uint32_t _size_queue_ptr                       ;
   public : uint32_t _size_instruction_ptr                 ;
+//public : uint32_t _size_queue_ptr                       ;
+//public : uint32_t _size_instruction_ptr                 ;
   public : bool     _have_port_queue_ptr                  ;
   public : bool     _have_port_instruction_ptr            ;
   public : bool     _have_port_branch_update_prediction_id;
+//public : bool     _have_port_queue_ptr                  ;
+//public : bool     _have_port_instruction_ptr            ;
+//public : bool     _have_port_branch_update_prediction_id;
     //-----[ methods ]-----------------------------------------------------------
+  public : Parameters  (uint32_t _size_queue                   ,
+                        uint32_t _nb_instruction               ,
+                        uint32_t _size_branch_update_prediction,
+                        uint32_t _size_general_data            );
+  public : Parameters  (uint32_t size_queue                   ,
+                        uint32_t nb_instruction               ,
+                        uint32_t size_branch_update_prediction,
+                        uint32_t size_general_data            ,
+                        bool     is_toplevel=false);
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Ifetch_queue.cpp

-              r81
+              r88
     log_printf(FUNC,Ifetch_queue,FUNCTION,"Begin");
+    log_printf(INFO,Ifetch_queue,FUNCTION,"Allocation");
+#if DEBUG_Ifetch_queue == true
+    log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
+    log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Allocation"),_name.c_str());
     allocation (
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Ifetch_queue,FUNCTION,"Allocation of statistics");
+        log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Allocation of statistics"),_name.c_str());
         statistics_allocation(param_statistics);
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
         log_printf(INFO,Ifetch_queue,FUNCTION,"Generate the vhdl");
+        log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Generate the vhdl"),_name.c_str());
         vhdl();
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         // constant output
 …
         PORT_WRITE(out_EVENT_RESET_ACK, internal_EVENT_RESET_ACK);
         log_printf(INFO,Ifetch_queue,FUNCTION,"Method - transition");
+        log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Method - transition"),_name.c_str());
         SC_METHOD (transition);
 …
 # endif
         log_printf(INFO,Ifetch_queue,FUNCTION,"Method - genMoore");
+        log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Method - genMoore"),_name.c_str());
         SC_METHOD (genMoore);
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();
 …
 #endif
     log_printf(INFO,Ifetch_queue,FUNCTION,"Deallocation");
+    log_printf(INFO,Ifetch_queue,FUNCTION,_("<%s> Deallocation"),_name.c_str());
     deallocation ();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Ifetch_queue_allocation.cpp

-              r81
+              r88
       ALLOC_VALACK_IN ( in_ADDRESS_VAL                        ,VAL);
       ALLOC_VALACK_OUT(out_ADDRESS_ACK                        ,ACK);
       ALLOC_SIGNAL_IN ( in_ADDRESS_INSTRUCTION_ADDRESS        ,"instruction_address"        ,Tgeneral_address_t ,_param->_size_general_data            );
       ALLOC_SIGNAL_IN ( in_ADDRESS_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_instruction_ptr         );
       ALLOC_SIGNAL_IN ( in_ADDRESS_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
       ALLOC_SIGNAL_IN ( in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
       ALLOC_SIGNAL_OUT(out_ADDRESS_IFETCH_QUEUE_ID            ,"ifetch_queue_id"            ,Tifetch_queue_ptr_t,_param->_size_queue_ptr               );
+      ALLOC_SIGNAL_IN ( in_ADDRESS_INSTRUCTION_ADDRESS        ,"instruction_address"        ,Tgeneral_address_t ,_param->_size_instruction_address        );
+      ALLOC_SIGNAL_IN ( in_ADDRESS_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr);
+      ALLOC_SIGNAL_IN ( in_ADDRESS_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state   );
+      ALLOC_SIGNAL_IN ( in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth          );
+      ALLOC_SIGNAL_OUT(out_ADDRESS_IFETCH_QUEUE_ID            ,"ifetch_queue_id"            ,Tifetch_queue_ptr_t,_param->_size_ifetch_queue_ptr);
+    }
 …
       ALLOC_INTERFACE("decod",OUT, EAST, "Send instruction bundle to the decod's stage.");
       ALLOC_SIGNAL_OUT(out_DECOD_ADDRESS                    ,"address"                    ,Tgeneral_address_t,_param->_size_general_data            );
       ALLOC_SIGNAL_OUT(out_DECOD_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_instruction_ptr         );
       ALLOC_SIGNAL_OUT(out_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t   ,_param->_size_branch_state            );
       ALLOC_SIGNAL_OUT(out_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_branch_update_prediction);
       ALLOC_SIGNAL_OUT(out_DECOD_EXCEPTION                  ,"exception"                  ,Texception_t      ,_param->_size_exception_ifetch        );
+      ALLOC_SIGNAL_OUT(out_DECOD_ADDRESS                    ,"address"                    ,Tgeneral_address_t,_param->_size_instruction_address         );
+      ALLOC_SIGNAL_OUT(out_DECOD_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_inst_ifetch_ptr );
+      ALLOC_SIGNAL_OUT(out_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t   ,_param->_size_branch_state    );
+      ALLOC_SIGNAL_OUT(out_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_depth           );
+      ALLOC_SIGNAL_OUT(out_DECOD_EXCEPTION                  ,"exception"                  ,Texception_t      ,_param->_size_exception_ifetch);
+    }
 …
       ALLOC_VALACK_IN ( in_ICACHE_RSP_VAL      ,VAL);
       ALLOC_VALACK_OUT(out_ICACHE_RSP_ACK      ,ACK);
       ALLOC_SIGNAL_IN ( in_ICACHE_RSP_PACKET_ID,"packet_id",Tpacket_t      ,_param->_size_queue_ptr   );
+      ALLOC_SIGNAL_IN ( in_ICACHE_RSP_PACKET_ID,"packet_id",Tpacket_t      ,_param->_size_ifetch_queue_ptr);
       ALLOC_SIGNAL_IN ( in_ICACHE_RSP_ERROR    ,"error"    ,Ticache_error_t,_param->_size_icache_error);
+    }
 …
     // ~~~~~[ Internal ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    internal_DECOD_VAL = new Tcontrol_t [_param->_nb_instruction];
+    _queue = new ifetch_queue_entry_t * [_param->_size_queue];
+    for (uint32_t i=0;i<_param->_size_queue; i++)
+      _queue [i] = new ifetch_queue_entry_t (_param->_nb_instruction);
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        internal_DECOD_VAL = new Tcontrol_t [_param->_nb_instruction];
+        _queue = new ifetch_queue_entry_t * [_param->_size_queue];
+        for (uint32_t i=0;i<_param->_size_queue; i++)
+          _queue [i] = new ifetch_queue_entry_t (_param->_nb_instruction);
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Ifetch_queue_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Ifetch_queue,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         delete     in_ADDRESS_VAL                        ;
         delete    out_ADDRESS_ACK                        ;
         if (_param->_have_port_queue_ptr)
+        if (_param->_have_port_ifetch_queue_ptr)
         delete    out_ADDRESS_IFETCH_QUEUE_ID            ;
         delete []  in_ADDRESS_INSTRUCTION_ENABLE         ;
         delete     in_ADDRESS_INSTRUCTION_ADDRESS        ;
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         delete     in_ADDRESS_INST_IFETCH_PTR            ;
         delete     in_ADDRESS_BRANCH_STATE               ;
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         delete     in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID;
         delete [] out_DECOD_VAL                          ;
 …
         delete [] out_DECOD_INSTRUCTION                  ;
         delete    out_DECOD_ADDRESS                      ;
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         delete    out_DECOD_INST_IFETCH_PTR              ;
         delete    out_DECOD_BRANCH_STATE                 ;
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         delete    out_DECOD_BRANCH_UPDATE_PREDICTION_ID  ;
         delete    out_DECOD_EXCEPTION                    ;
         delete     in_ICACHE_RSP_VAL                     ;
         delete    out_ICACHE_RSP_ACK                     ;
         if (_param->_have_port_queue_ptr)
+        if (_param->_have_port_ifetch_queue_ptr)
         delete     in_ICACHE_RSP_PACKET_ID               ;
         delete []  in_ICACHE_RSP_INSTRUCTION             ;
 …
         delete    out_EVENT_RESET_ACK                    ;
+      }
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        delete    internal_DECOD_VAL;
+        delete [] _queue;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete    internal_DECOD_VAL;
-    delete [] _queue;
     delete    _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Ifetch_queue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Ifetch_queue_genMoore.cpp

-              r81
+              r88
     PORT_WRITE(out_ADDRESS_ACK            , internal_ADDRESS_ACK);
     if (_param->_have_port_queue_ptr)
+    if (_param->_have_port_ifetch_queue_ptr)
     PORT_WRITE(out_ADDRESS_IFETCH_QUEUE_ID, reg_PTR_WRITE);
 …
     PORT_WRITE(out_DECOD_ADDRESS                    , _queue[reg_PTR_READ]->_address                    );
     if (_param->_have_port_instruction_ptr)
+    if (_param->_have_port_inst_ifetch_ptr)
     PORT_WRITE(out_DECOD_INST_IFETCH_PTR            , _queue[reg_PTR_READ]->_inst_ifetch_ptr            );
     PORT_WRITE(out_DECOD_BRANCH_STATE               , _queue[reg_PTR_READ]->_branch_state               );
     if (_param->_have_port_branch_update_prediction_id)
+    if (_param->_have_port_depth)
     PORT_WRITE(out_DECOD_BRANCH_UPDATE_PREDICTION_ID, _queue[reg_PTR_READ]->_branch_update_prediction_id);
     PORT_WRITE(out_DECOD_EXCEPTION                  , _queue[reg_PTR_READ]->_exception                  );

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Ifetch_queue_transition.cpp

-              r85
+              r88
   void Ifetch_queue::transition (void)
+  {
     log_printf(FUNC,Ifetch_queue,FUNCTION,"Begin");
+    log_begin(Ifetch_queue,FUNCTION);
     if (PORT_READ(in_NRESET) == 0)
 …
     else
+      {
-        log_printf(NONE,Ifetch_queue,FUNCTION," * KANE address : 0x%x",PORT_READ(in_ADDRESS_INSTRUCTION_ADDRESS));
         // ==========================================================
         // =====[ ADDRESS ]==========================================
 …
 #ifdef STATISTICS
+            (*_sum_transaction_address) ++;
+            if (usage_is_set(_usage,USE_STATISTICS))
+              (*_sum_transaction_address) ++;
 #endif
 …
                 Tcontrol_t enable = PORT_READ(in_ADDRESS_INSTRUCTION_ENABLE [i]);
 #ifdef STATISTICS
+                (*_sum_inst_enable) += enable;
+                if (usage_is_set(_usage,USE_STATISTICS))
+                  (*_sum_inst_enable) += enable;
 #endif
                 _queue[reg_PTR_WRITE]->_instruction_enable [i]      = enable;
 …
             _queue[reg_PTR_WRITE]->_address                     = PORT_READ(in_ADDRESS_INSTRUCTION_ADDRESS        );
             _queue[reg_PTR_WRITE]->_inst_ifetch_ptr             = (_param->_have_port_instruction_ptr)?PORT_READ(in_ADDRESS_INST_IFETCH_PTR            ):0;
+            _queue[reg_PTR_WRITE]->_inst_ifetch_ptr             = (_param->_have_port_inst_ifetch_ptr)?PORT_READ(in_ADDRESS_INST_IFETCH_PTR            ):0;
             _queue[reg_PTR_WRITE]->_branch_state                = PORT_READ(in_ADDRESS_BRANCH_STATE               );
             _queue[reg_PTR_WRITE]->_branch_update_prediction_id = (_param->_have_port_branch_update_prediction_id)?PORT_READ(in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID):0;
+            _queue[reg_PTR_WRITE]->_branch_update_prediction_id = (_param->_have_port_depth)?PORT_READ(in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID):0;
             reg_PTR_WRITE = (reg_PTR_WRITE+1)%_param->_size_queue;
 …
         if (PORT_READ(in_ICACHE_RSP_VAL) and internal_ICACHE_RSP_ACK)
+          {
             Tpacket_t ptr = (_param->_have_port_queue_ptr)?PORT_READ(in_ICACHE_RSP_PACKET_ID):0;
+            Tpacket_t ptr = (_param->_have_port_ifetch_queue_ptr)?PORT_READ(in_ICACHE_RSP_PACKET_ID):0;
             for (uint32_t i=0; i<_param->_nb_instruction; i++)
 …
+          }
 #if DEBUG >= DEBUG_TRACE
         log_printf(TRACE,Ifetch_queue,FUNCTION,"Dump ifetch_queue");
         log_printf(TRACE,Ifetch_queue,FUNCTION," * reg_PTR_WRITE : %d",reg_PTR_WRITE);
         log_printf(TRACE,Ifetch_queue,FUNCTION," * reg_PTR_READ  : %d",reg_PTR_READ );
+#if defined(DEBUG) and (DEBUG >= DEBUG_TRACE)
+        log_printf(TRACE,Ifetch_queue,FUNCTION,"  * Dump ifetch_queue");
+        log_printf(TRACE,Ifetch_queue,FUNCTION,"    * reg_PTR_WRITE : %d",reg_PTR_WRITE);
+        log_printf(TRACE,Ifetch_queue,FUNCTION,"    * reg_PTR_READ  : %d",reg_PTR_READ );
         for (uint32_t i=0; i<_param->_size_queue; i++)
+          {
             log_printf(TRACE,Ifetch_queue,FUNCTION," * [%d] %s %.8x %d - %d %d %d", i, toString(_queue [i]->_state).c_str(), _queue [i]->_address,_queue [i]->_inst_ifetch_ptr,_queue [i]->_branch_state,_queue [i]->_branch_update_prediction_id,_queue [i]->_exception);
+            log_printf(TRACE,Ifetch_queue,FUNCTION,"    * [%d] %s %.8x %d - %d %d %d", i, toString(_queue [i]->_state).c_str(), _queue [i]->_address,_queue [i]->_inst_ifetch_ptr,_queue [i]->_branch_state,_queue [i]->_branch_update_prediction_id,_queue [i]->_exception);
             for (uint32_t j=0; j<_param->_nb_instruction; j++)
               log_printf(TRACE,Ifetch_queue,FUNCTION,"    * %d %.8x", _queue [i]->_instruction_enable[j], _queue [i]->_instruction[j]);
+              log_printf(TRACE,Ifetch_queue,FUNCTION,"      * %d %.8x", _queue [i]->_instruction_enable[j], _queue [i]->_instruction[j]);
+          }
 #endif
 #ifdef STATISTICS
+        for (uint32_t i=0; i<_param->_size_queue; i++)
+          switch (_queue[i]->_state)
+            {
+            case IFETCH_QUEUE_STATE_EMPTY          : break;
+            case IFETCH_QUEUE_STATE_WAIT_RSP       : (*_sum_use_queue_wait_rsp      ) ++; break;
+            case IFETCH_QUEUE_STATE_HAVE_RSP       : (*_sum_use_queue_have_rsp      ) ++; break;
+            case IFETCH_QUEUE_STATE_ERROR_WAIT_RSP : (*_sum_use_queue_error_wait_rsp) ++; break;
+            default : break;
+            }
+        if (usage_is_set(_usage,USE_STATISTICS))
+          for (uint32_t i=0; i<_param->_size_queue; i++)
+            switch (_queue[i]->_state)
+              {
+              case IFETCH_QUEUE_STATE_EMPTY          : break;
+              case IFETCH_QUEUE_STATE_WAIT_RSP       : (*_sum_use_queue_wait_rsp      ) ++; break;
+              case IFETCH_QUEUE_STATE_HAVE_RSP       : (*_sum_use_queue_have_rsp      ) ++; break;
+              case IFETCH_QUEUE_STATE_ERROR_WAIT_RSP : (*_sum_use_queue_error_wait_rsp) ++; break;
+              default : break;
+              }
 #endif
+      }
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     end_cycle ();
 #endif
     log_printf(FUNC,Ifetch_queue,FUNCTION,"End");
+    log_end(Ifetch_queue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Parameters.cpp

-              r81
+              r88
                           uint32_t nb_instruction               ,
                           uint32_t size_branch_update_prediction,
+                          uint32_t size_general_data            )
+                          uint32_t size_general_data            ,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Ifetch_queue,FUNCTION,"Begin");
 …
     _size_queue                            = size_queue                   ;
     _nb_instruction                        = nb_instruction               ;
     _size_branch_update_prediction         = size_branch_update_prediction;
     _size_general_data                     = size_general_data            ;
+//  _size_branch_update_prediction         = size_branch_update_prediction;
+//  _size_general_data                     = size_general_data            ;
+    _size_queue_ptr                        = log2(size_queue);
+    _size_instruction_ptr                  = log2(nb_instruction);
+    test();
+    _have_port_queue_ptr                   = _size_queue_ptr > 0;
+    _have_port_instruction_ptr             = _size_instruction_ptr > 0;
+    _have_port_branch_update_prediction_id = size_branch_update_prediction > 0;
+    test();
+    if (is_toplevel)
+      {
+        _size_instruction_address   = size_general_data;
+        _size_ifetch_queue_ptr      = log2(size_queue);
+        _size_inst_ifetch_ptr       = log2(nb_instruction);
+        _size_depth                 = size_branch_update_prediction;
+        _have_port_ifetch_queue_ptr = _size_ifetch_queue_ptr > 0;
+        _have_port_inst_ifetch_ptr  = _size_inst_ifetch_ptr > 0;
+        _have_port_depth            = _size_depth > 0;
+        copy ();
+      }
     log_printf(FUNC,Ifetch_queue,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Ifetch_queue::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Ifetch_queue,FUNCTION,"Begin");
+    log_printf(FUNC,Ifetch_queue,FUNCTION,"End");
+  };
 }; // end namespace ifetch_queue
 }; // end namespace ifetch_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Parameters_msg_error.cpp

-              r81
+              r88
     if (_size_queue == 1)
       test.warning("To best perfomance, size_queue must be > 1.");
+      test.warning("To best perfomance, size_queue must be > 1.\n");
-//     if (not _have_port_queue_ptr)
-//       test.information("They have not port '..._QUEUE_PTR'.");
-//     if (not _have_port_instruction_ptr)
-//       test.information("They have not port '..._INST_IFETCH_PTR'.");
-//     if (not _have_port_branch_update_prediction_id)
-//       test.information("They have not port '..._BRANCH_UPDATE_PREDICTION_ID'.");
     log_printf(FUNC,Ifetch_queue,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue/src/Parameters_print.cpp

-              r81
+              r88
     xml.singleton_begin("size_queue                   "); xml.attribut("value",toString(_size_queue                   )); xml.singleton_end();
     xml.singleton_begin("nb_instruction               "); xml.attribut("value",toString(_nb_instruction               )); xml.singleton_end();
     xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
     xml.singleton_begin("size_general_data            "); xml.attribut("value",toString(_size_general_data            )); xml.singleton_end();
+//  xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
+//  xml.singleton_begin("size_general_data            "); xml.attribut("value",toString(_size_general_data            )); xml.singleton_end();
     xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/SelfTest/Makefile

r81	r88
24	24	library_clean : Ifetch_unit_Glue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/SelfTest/src/main.cpp

-              r85
+              r88
+    {
       morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::ifetch_unit_glue::Parameters * param = new morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::ifetch_unit_glue::Parameters
+        (_size_address);
+        (_size_address,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/SelfTest/src/test.cpp

-              r85
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Ifetch_unit_Glue * _Ifetch_unit_Glue = new Ifetch_unit_Glue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/include/Parameters.h

-              r85
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
   public : uint32_t _size_address;
+//public : uint32_t _size_address;
     //-----[ methods ]-----------------------------------------------------------
+  public : Parameters  (uint32_t size_address);
+  public : Parameters  (uint32_t size_address,
+                        bool     is_toplevel=false);
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/src/Ifetch_unit_Glue.cpp

-              r85
+              r88
     log_printf(FUNC,Ifetch_unit_Glue,FUNCTION,"Begin");
+#if DEBUG_Ifetch_unit_Glue == true
+    log_printf(INFO,Ifetch_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Ifetch_unit_Glue,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Ifetch_unit_Glue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
+    PORT_WRITE(out_ICACHE_REQ_TYPE,ICACHE_TYPE_LOAD);
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        // Write constant
+        PORT_WRITE(out_ICACHE_REQ_TYPE,ICACHE_TYPE_LOAD);
-    if (_usage & USE_SYSTEMC)
+      {
 # if defined(STATISTICS) or defined(VHDL_TESTBENCH)
         log_printf(INFO,Ifetch_unit_Glue,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/src/Ifetch_unit_Glue_allocation.cpp

-              r85
+              r88
       ALLOC_SIGNAL_IN ( in_ICACHE_REQ_QUEUE_ACK      ,"queue_ack"      ,Tcontrol_t,1);
       ALLOC_SIGNAL_OUT(out_ICACHE_REQ_TYPE           ,"type"           ,Ticache_type_t,_param->_size_icache_type);
       ALLOC_SIGNAL_OUT(out_ICACHE_REQ_ADDRESS        ,"address"        ,Taddress_t,_param->_size_address);
       ALLOC_SIGNAL_IN ( in_ICACHE_REQ_ADDRESS_ADDRESS,"address_address",Taddress_t,_param->_size_address);
       ALLOC_SIGNAL_OUT(out_ICACHE_REQ_QUEUE_ADDRESS  ,"queue_address"  ,Taddress_t,_param->_size_address);
+      ALLOC_SIGNAL_OUT(out_ICACHE_REQ_ADDRESS        ,"address"        ,Taddress_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN ( in_ICACHE_REQ_ADDRESS_ADDRESS,"address_address",Taddress_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_OUT(out_ICACHE_REQ_QUEUE_ADDRESS  ,"queue_address"  ,Taddress_t,_param->_size_instruction_address);
+    }
 …
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/src/Ifetch_unit_Glue_deallocation.cpp

r85	r88
23	23	log_printf(FUNC,Ifetch_unit_Glue,FUNCTION,"Begin");
24	24
25		if (~~_usage & USE_SYSTEMC~~)
	25	if (usage_is_set(_usage,USE_SYSTEMC))
26	26	{
27	27	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/src/Ifetch_unit_Glue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/src/Parameters.cpp

-              r85
+              r88
 #undef  FUNCTION
 #define FUNCTION "Ifetch_unit_Glue::Parameters"
+  Parameters::Parameters (uint32_t size_address)
+  Parameters::Parameters (uint32_t size_address,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Ifetch_unit_Glue,FUNCTION,"Begin");
     _size_address = size_address;
+    test();
+    test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address;
+        copy ();
+      }
     log_printf(FUNC,Ifetch_unit_Glue,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Ifetch_unit_Glue::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Ifetch_unit_Glue,FUNCTION,"Begin");
+    log_printf(FUNC,Ifetch_unit_Glue,FUNCTION,"End");
+  };
 }; // end namespace ifetch_unit_glue
 }; // end namespace ifetch_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue/src/Parameters_print.cpp

r85	r88
27	27
28	28	xml.balise_open("ifetch_unit_glue");
29		xml.singleton_begin("size_address"); xml.attribut("value",toString(_size_address)); xml.singleton_end();
	29	// xml.singleton_begin("size_address"); xml.attribut("value",toString(_size_address)); xml.singleton_end();
30	30	xml.balise_close();
31	31

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Ifetch_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_instruction                ,
          _size_branch_update_prediction ,
+         _size_general_data             );
+         _size_general_data             ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/SelfTest/src/test.cpp

-              r85
+              r88
  */
 #define NB_ITERATION  128
+#define NB_ITERATION  1024
 #define CYCLE_MAX     (128*NB_ITERATION)
 …
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+  _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Ifetch_unit * _Ifetch_unit = new Ifetch_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC_SC_SIGNAL (out_EVENT_ACK                          ,"out_EVENT_ACK                          ",Tcontrol_t           );
   ALLOC_SC_SIGNAL ( in_EVENT_ADDRESS                      ," in_EVENT_ADDRESS                      ",Tgeneral_address_t   );
+  ALLOC_SC_SIGNAL ( in_EVENT_ADDRESS_NEXT                 ," in_EVENT_ADDRESS_NEXT                 ",Tgeneral_address_t   );
+  ALLOC_SC_SIGNAL ( in_EVENT_ADDRESS_NEXT_VAL             ," in_EVENT_ADDRESS_NEXT_VAL             ",Tcontrol_t           );
+  ALLOC_SC_SIGNAL ( in_EVENT_IS_DS_TAKE                   ," in_EVENT_IS_DS_TAKE                   ",Tcontrol_t           );
   /********************************************************
 …
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_ICACHE_REQ_ACK                     );
 //INSTANCE_SC_SIGNAL (_Ifetch_unit,out_ICACHE_REQ_THREAD_ID               );
   if (_param->_have_port_queue_ptr)
+  if (_param->_have_port_ifetch_queue_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_ICACHE_REQ_PACKET_ID               );
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_ICACHE_REQ_ADDRESS                 );
 …
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_ICACHE_RSP_ACK                     );
 //INSTANCE_SC_SIGNAL (_Ifetch_unit, in_ICACHE_RSP_THREAD_ID               );
   if (_param->_have_port_queue_ptr)
+  if (_param->_have_port_ifetch_queue_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_ICACHE_RSP_PACKET_ID               );
   INSTANCE1_SC_SIGNAL(_Ifetch_unit, in_ICACHE_RSP_INSTRUCTION             ,_param->_nb_instruction);
 …
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_PREDICT_PC_NEXT_IS_DS_TAKE         );
   INSTANCE1_SC_SIGNAL(_Ifetch_unit, in_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_instruction);
   if (_param->_have_port_instruction_ptr)
+  if (_param->_have_port_inst_ifetch_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_PREDICT_INST_IFETCH_PTR            );
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_PREDICT_BRANCH_STATE               );
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_PREDICT_BRANCH_UPDATE_PREDICTION_ID);
   INSTANCE1_SC_SIGNAL(_Ifetch_unit,out_DECOD_VAL                          ,_param->_nb_instruction);
 …
 //INSTANCE_SC_SIGNAL (_Ifetch_unit,out_DECOD_CONTEXT_ID                   );
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_DECOD_ADDRESS                      );
   if (_param->_have_port_instruction_ptr)
+  if (_param->_have_port_inst_ifetch_ptr)
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_DECOD_INST_IFETCH_PTR              );
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_DECOD_BRANCH_STATE                 );
   if (_param->_have_port_branch_update_prediction_id)
+  if (_param->_have_port_depth)
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_DECOD_BRANCH_UPDATE_PREDICTION_ID  );
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_DECOD_EXCEPTION                    );
 …
   INSTANCE_SC_SIGNAL (_Ifetch_unit,out_EVENT_ACK                          );
   INSTANCE_SC_SIGNAL (_Ifetch_unit, in_EVENT_ADDRESS                      );
+  INSTANCE_SC_SIGNAL (_Ifetch_unit, in_EVENT_ADDRESS_NEXT                 );
+  INSTANCE_SC_SIGNAL (_Ifetch_unit, in_EVENT_ADDRESS_NEXT_VAL             );
+  INSTANCE_SC_SIGNAL (_Ifetch_unit, in_EVENT_IS_DS_TAKE                   );
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
   Tcontrol_t      nn_val  = false;
   Tgeneral_data_t c_addr  = 0x100;
   Tgeneral_data_t n_addr  = 0x100;
   Tgeneral_data_t nn_addr = 0x100;
+  Tgeneral_data_t c_addr  = 0x100>>2;
+  Tgeneral_data_t n_addr  = 0x100>>2;
+  Tgeneral_data_t nn_addr = 0x100>>2;
   Tcontrol_t      c_enable [_param->_nb_instruction];
 …
     TEST(Tcontrol_t,out_DECOD_VAL [i]->read(), 0);
   LABEL("Send Reset");
   do
+    {
       in_EVENT_VAL    ->write(1);
       in_EVENT_ADDRESS->write(n_addr);
       SC_START(1);
     } while (out_EVENT_ACK->read() == false);
   in_EVENT_VAL    ->write(0);
+//   LABEL("Send Reset");
+//   do
+//     {
+//       in_EVENT_VAL    ->write(1);
+//       in_EVENT_ADDRESS->write(n_addr);
+//       SC_START(1);
+//     } while (out_EVENT_ACK->read() == false);
+//   in_EVENT_VAL    ->write(0);
   n_val = 1;
 …
       // EVENT
+      in_EVENT_VAL    ->write((rand()%100)<percent_transaction_event  );
+      in_EVENT_ADDRESS->write(0x100);
+      in_EVENT_VAL             ->write((rand()%100)<percent_transaction_event  );
+      in_EVENT_ADDRESS         ->write(0x77);
+      in_EVENT_ADDRESS_NEXT    ->write(0x171);
+      Tcontrol_t is_ds_take = rand();
+      in_EVENT_ADDRESS_NEXT_VAL->write(is_ds_take);
+      in_EVENT_IS_DS_TAKE      ->write(is_ds_take);
       // ICACHE_REQ
 …
           LABEL("ICACHE_REQ : Transaction accepted");
           Tpacket_t  packet  = (_param->_have_port_queue_ptr)?out_ICACHE_REQ_PACKET_ID->read():0;
+          Tpacket_t  packet  = (_param->_have_port_ifetch_queue_ptr)?out_ICACHE_REQ_PACKET_ID->read():0;
           Taddress_t address = out_ICACHE_REQ_ADDRESS->read();
 …
         if (find)
+          {
             if (_param->_have_port_instruction_ptr)
+            if (_param->_have_port_inst_ifetch_ptr)
             TEST(Tinst_ifetch_ptr_t, out_DECOD_INST_IFETCH_PTR            ->read(), 0);
             TEST(Tbranch_state_t   , out_DECOD_BRANCH_STATE               ->read(), 0);
             if (_param->_have_port_branch_update_prediction_id)
+            if (_param->_have_port_depth)
             TEST(Tprediction_ptr_t , out_DECOD_BRANCH_UPDATE_PREDICTION_ID->read(), 0);
             TEST(Texception_t      , out_DECOD_EXCEPTION                  ->read(), 0);
 …
           c_val           = false;
           n_val           = true;
+          nn_val          = false;
+          n_addr         = in_EVENT_ADDRESS->read();
+          n_is_ds_take   = 0;
+          n_addr          = in_EVENT_ADDRESS->read();
+          n_is_ds_take    = in_EVENT_IS_DS_TAKE->read();
+          nn_val          = in_EVENT_ADDRESS_NEXT_VAL->read();
+          nn_addr         = in_EVENT_ADDRESS_NEXT    ->read();
+          nn_is_ds_take   = 0;
           n_enable [0] = 1;
 …
   delete    out_EVENT_ACK                           ;
   delete     in_EVENT_ADDRESS                       ;
+  delete     in_EVENT_ADDRESS_NEXT                  ;
+  delete     in_EVENT_ADDRESS_NEXT_VAL              ;
+  delete     in_EVENT_IS_DS_TAKE                    ;
   delete    param_cache;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/include/Ifetch_unit.h

-              r82
+              r88
   public    : SC_OUT(Tcontrol_t        )    * out_EVENT_ACK                           ;
   public    : SC_IN (Tgeneral_address_t)    *  in_EVENT_ADDRESS                       ;
+  public    : SC_IN (Tgeneral_address_t)    *  in_EVENT_ADDRESS_NEXT                  ;
+  public    : SC_IN (Tcontrol_t        )    *  in_EVENT_ADDRESS_NEXT_VAL              ;
+  public    : SC_IN (Tcontrol_t        )    *  in_EVENT_IS_DS_TAKE                    ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/include/Parameters.h

-              r81
+              r88
   public : uint32_t _size_queue                   ;
   public : uint32_t _nb_instruction               ;
   public : uint32_t _size_address                 ;
   public : uint32_t _size_branch_update_prediction;
   public : uint32_t _size_queue_ptr                       ;
   public : uint32_t _size_instruction_ptr                 ;
   public : bool     _have_port_queue_ptr                  ;
   public : bool     _have_port_instruction_ptr            ;
   public : bool     _have_port_branch_update_prediction_id;
+//public : uint32_t _size_address                 ;
+//public : uint32_t _size_branch_update_prediction;
+//
+//public : uint32_t _size_queue_ptr                       ;
+//public : uint32_t _size_instruction_ptr                 ;
+//
+//public : bool     _have_port_queue_ptr                  ;
+//public : bool     _have_port_instruction_ptr            ;
+//public : bool     _have_port_branch_update_prediction_id;
   public :morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::address_management::Parameters * _param_address_management;
 …
                         uint32_t nb_instruction               ,
                         uint32_t size_branch_update_prediction,
+                        uint32_t size_address                 );
+                        uint32_t size_address                 ,
+                        bool     is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/src/Ifetch_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Ifetch_unit,FUNCTION,"Begin");
+#if DEBUG_Ifetch_unit == true
+    log_printf(INFO,Ifetch_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Ifetch_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Ifetch_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Ifetch_unit,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/src/Ifetch_unit_allocation.cpp

-              r85
+              r88
     // ~~~~~[ Interface "icache_req" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC_INTERFACE("icache_req",OUT, WEST, "Instruction cache request.");
+      ALLOC_INTERFACE("icache_req",OUT, WEST, _("Instruction cache request."));
       ALLOC_VALACK_OUT(out_ICACHE_REQ_VAL      ,VAL);
       ALLOC_VALACK_IN ( in_ICACHE_REQ_ACK      ,ACK);
     //ALLOC_SIGNAL_OUT(out_ICACHE_REQ_THREAD_ID,"thread_id",Tcontext_t           ,_param->_size_context_id );
       ALLOC_SIGNAL_OUT(out_ICACHE_REQ_PACKET_ID,"packet_id",Tpacket_t            ,_param->_size_queue_ptr  );
       ALLOC_SIGNAL_OUT(out_ICACHE_REQ_ADDRESS  ,"address"  ,Ticache_instruction_t,_param->_size_address    );
+      ALLOC_SIGNAL_OUT(out_ICACHE_REQ_PACKET_ID,"packet_id",Tpacket_t            ,_param->_size_ifetch_queue_ptr  );
+      ALLOC_SIGNAL_OUT(out_ICACHE_REQ_ADDRESS  ,"address"  ,Ticache_instruction_t,_param->_size_instruction_address    );
       ALLOC_SIGNAL_OUT(out_ICACHE_REQ_TYPE     ,"type"     ,Ticache_type_t       ,_param->_size_icache_type);
+    }
 …
     // ~~~~~[ Interface "icache_rsp" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC_INTERFACE("icache_rsp",IN , WEST, "Instruction cache respons.");
+      ALLOC_INTERFACE("icache_rsp",IN , WEST, _("Instruction cache respons."));
       ALLOC_VALACK_IN  ( in_ICACHE_RSP_VAL        ,VAL);
       ALLOC_VALACK_OUT (out_ICACHE_RSP_ACK        ,ACK);
     //ALLOC_SIGNAL_IN  ( in_ICACHE_RSP_THREAD_ID  ,"thread_id"  ,Tcontext_t           ,_param->_size_context_id  );
       ALLOC_SIGNAL_IN  ( in_ICACHE_RSP_PACKET_ID  ,"packet_id"  ,Tpacket_t            ,_param->_size_queue_ptr   );
+      ALLOC_SIGNAL_IN  ( in_ICACHE_RSP_PACKET_ID  ,"packet_id"  ,Tpacket_t            ,_param->_size_ifetch_queue_ptr   );
       ALLOC_SIGNAL_IN  ( in_ICACHE_RSP_ERROR      ,"error"      ,Ticache_error_t      ,_param->_size_icache_error);
+    }
+    {
       ALLOC1_INTERFACE("icache_rsp",IN , WEST, "Instruction cache respons.",_param->_nb_instruction);
+      ALLOC1_INTERFACE("icache_rsp",IN , WEST, _("Instruction cache respons."),_param->_nb_instruction);
       ALLOC1_SIGNAL_IN ( in_ICACHE_RSP_INSTRUCTION,"instruction",Ticache_instruction_t,_param->_size_instruction );
 …
     // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC_INTERFACE("predict",OUT, NORTH, "Acces Instruction cache respons.");
+      ALLOC_INTERFACE("predict",OUT, NORTH, _("Predict the next pc."));
       ALLOC_VALACK_OUT (out_PREDICT_VAL                        ,VAL);
       ALLOC_VALACK_IN  ( in_PREDICT_ACK                        ,ACK);
       ALLOC_SIGNAL_OUT (out_PREDICT_PC_PREVIOUS                ,"pc_previous"                ,Tgeneral_address_t,_param->_size_address);
       ALLOC_SIGNAL_OUT (out_PREDICT_PC_CURRENT                 ,"pc_current"                 ,Tgeneral_address_t,_param->_size_address);
+      ALLOC_SIGNAL_OUT (out_PREDICT_PC_PREVIOUS                ,"pc_previous"                ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_OUT (out_PREDICT_PC_CURRENT                 ,"pc_current"                 ,Tgeneral_address_t,_param->_size_instruction_address);
       ALLOC_SIGNAL_OUT (out_PREDICT_PC_CURRENT_IS_DS_TAKE      ,"pc_current_is_ds_take"      ,Tcontrol_t        ,1);
       ALLOC_SIGNAL_IN  ( in_PREDICT_PC_NEXT                    ,"pc_next"                    ,Tgeneral_address_t,_param->_size_address);
+      ALLOC_SIGNAL_IN  ( in_PREDICT_PC_NEXT                    ,"pc_next"                    ,Tgeneral_address_t,_param->_size_instruction_address);
       ALLOC_SIGNAL_IN  ( in_PREDICT_PC_NEXT_IS_DS_TAKE         ,"pc_next_is_ds_take"         ,Tcontrol_t        ,1);
       ALLOC_SIGNAL_IN  ( in_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_instruction_ptr);
+      ALLOC_SIGNAL_IN  ( in_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_inst_ifetch_ptr);
       ALLOC_SIGNAL_IN  ( in_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t   ,_param->_size_branch_state);
       ALLOC_SIGNAL_IN  ( in_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_branch_update_prediction);
+    }
+    {
       ALLOC1_INTERFACE("predict",IN , NORTH, "Acces Instruction cache respons.",_param->_nb_instruction);
+      ALLOC_SIGNAL_IN  ( in_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_depth);
+    }
+    {
+      ALLOC1_INTERFACE("predict",IN , NORTH, _("Predict the next pc."),_param->_nb_instruction);
       ALLOC1_SIGNAL_IN ( in_PREDICT_INSTRUCTION_ENABLE         ,"instruction_enable"         ,Tcontrol_t        ,1);
 …
     // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC_INTERFACE("decod",OUT , EAST, "Send bundle to the decod unit.");
+      ALLOC_INTERFACE("decod",OUT , EAST, _("Send bundle to the decod unit."));
     //ALLOC_SIGNAL_OUT (out_DECOD_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t        ,_param->_size_context_id);
       ALLOC_SIGNAL_OUT (out_DECOD_ADDRESS                    ,"address"                    ,Tgeneral_address_t,_param->_size_address);
       ALLOC_SIGNAL_OUT (out_DECOD_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_instruction_ptr);
+      ALLOC_SIGNAL_OUT (out_DECOD_ADDRESS                    ,"address"                    ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_OUT (out_DECOD_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t,_param->_size_inst_ifetch_ptr);
       ALLOC_SIGNAL_OUT (out_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t   ,_param->_size_branch_state);
       ALLOC_SIGNAL_OUT (out_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_branch_update_prediction);
+      ALLOC_SIGNAL_OUT (out_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t ,_param->_size_depth);
       ALLOC_SIGNAL_OUT (out_DECOD_EXCEPTION                  ,"exception"                  ,Texception_t      ,_param->_size_exception_ifetch);
+    }
+    {
       ALLOC1_INTERFACE("decod",OUT , EAST, "Send bundle to the decod unit.",_param->_nb_instruction);
+      ALLOC1_INTERFACE("decod",OUT , EAST, _("Send bundle to the decod unit."),_param->_nb_instruction);
       ALLOC1_VALACK_OUT(out_DECOD_VAL                        ,VAL);
 …
     // ~~~~~[ Interface "event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      ALLOC_INTERFACE("event",IN , NORTH, "Event interface.");
+      ALLOC_VALACK_IN ( in_EVENT_VAL    ,VAL);
+      ALLOC_VALACK_OUT(out_EVENT_ACK    ,ACK);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS,"address",Tgeneral_address_t,_param->_size_address);
+      ALLOC_INTERFACE("event",IN , NORTH, _("Event interface."));
+      ALLOC_VALACK_IN ( in_EVENT_VAL              ,VAL);
+      ALLOC_VALACK_OUT(out_EVENT_ACK              ,ACK);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS          ,"address"         ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS_NEXT     ,"address_next"    ,Tgeneral_address_t,_param->_size_instruction_address);
+      ALLOC_SIGNAL_IN ( in_EVENT_ADDRESS_NEXT_VAL ,"address_next_val",Tcontrol_t,1);
+      ALLOC_SIGNAL_IN ( in_EVENT_IS_DS_TAKE       ,"is_ds_take"      ,Tcontrol_t,1);
+    }
 …
+    {
       name = _name+"_address_management";
       std::cout << "Create   : " << name << std::endl;
+      log_printf(Ifetch_unit,Core,FUNCTION,_("Create   : %s"),name.c_str());
       _component_address_management = new morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::address_management::Address_management
 …
+    {
       name = _name+"_ifetch_queue";
       std::cout << "Create   : " << name << std::endl;
+      log_printf(Ifetch_unit,Core,FUNCTION,_("Create   : %s"),name.c_str());
       _component_ifetch_queue = new morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::ifetch_queue::Ifetch_queue
 …
+    {
       name = _name+"_ifetch_unit_glue";
       std::cout << "Create   : " << name << std::endl;
+      log_printf(Ifetch_unit,Core,FUNCTION,_("Create   : %s"),name.c_str());
       _component_ifetch_unit_glue = new morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::ifetch_unit_glue::Ifetch_unit_Glue
 …
+    {
       src = _name+"_address_management";
       std::cout << "Instance : " << src << std::endl;
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
 …
+          }
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         COMPONENT_MAP(_component,src ,"out_ADDRESS_INST_IFETCH_PTR"            ,
                                  dest, "in_ADDRESS_INST_IFETCH_PTR"            );
         COMPONENT_MAP(_component,src ,"out_ADDRESS_BRANCH_STATE"               ,
                                  dest, "in_ADDRESS_BRANCH_STATE"               );
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         COMPONENT_MAP(_component,src ,"out_ADDRESS_BRANCH_UPDATE_PREDICTION_ID",
                                  dest, "in_ADDRESS_BRANCH_UPDATE_PREDICTION_ID");
 …
         PORT_MAP(_component,src , "in_PREDICT_PC_NEXT_IS_DS_TAKE"
                            ,dest, "in_PREDICT_PC_NEXT_IS_DS_TAKE"         );
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         PORT_MAP(_component,src , "in_PREDICT_INST_IFETCH_PTR"
                            ,dest, "in_PREDICT_INST_IFETCH_PTR"            );
         PORT_MAP(_component,src , "in_PREDICT_BRANCH_STATE"
                            ,dest, "in_PREDICT_BRANCH_STATE"               );
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         PORT_MAP(_component,src , "in_PREDICT_BRANCH_UPDATE_PREDICTION_ID"
                            ,dest, "in_PREDICT_BRANCH_UPDATE_PREDICTION_ID");
 …
         dest = _name;
+        PORT_MAP(_component,src , "in_EVENT_ADDRESS",dest, "in_EVENT_ADDRESS");
+        PORT_MAP(_component,src , "in_EVENT_ADDRESS"         ,dest , "in_EVENT_ADDRESS"          );
+        PORT_MAP(_component,src , "in_EVENT_ADDRESS_NEXT"    ,dest , "in_EVENT_ADDRESS_NEXT"     );
+        PORT_MAP(_component,src , "in_EVENT_ADDRESS_NEXT_VAL",dest , "in_EVENT_ADDRESS_NEXT_VAL" );
+        PORT_MAP(_component,src , "in_EVENT_IS_DS_TAKE"      ,dest , "in_EVENT_IS_DS_TAKE"       );
+      }
+    }
 …
+    {
       src = _name+"_ifetch_queue";
       std::cout << "Instance : " << src << std::endl;
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
 …
 #endif
         if (_param->_have_port_queue_ptr)
+        if (_param->_have_port_ifetch_queue_ptr)
         PORT_MAP(_component,src ,"out_ADDRESS_IFETCH_QUEUE_ID"            ,
                             dest,"out_ICACHE_REQ_PACKET_ID"               );
 …
         PORT_MAP(_component,src ,"out_DECOD_ADDRESS"                    ,dest,"out_DECOD_ADDRESS"                    );
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         PORT_MAP(_component,src ,"out_DECOD_INST_IFETCH_PTR"            ,dest,"out_DECOD_INST_IFETCH_PTR"            );
         PORT_MAP(_component,src ,"out_DECOD_BRANCH_STATE"               ,dest,"out_DECOD_BRANCH_STATE"               );
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         PORT_MAP(_component,src ,"out_DECOD_BRANCH_UPDATE_PREDICTION_ID",dest,"out_DECOD_BRANCH_UPDATE_PREDICTION_ID");
         PORT_MAP(_component,src ,"out_DECOD_EXCEPTION"                  ,dest,"out_DECOD_EXCEPTION"                  );
 …
         PORT_MAP(_component,src , "in_ICACHE_RSP_VAL"      ,dest, "in_ICACHE_RSP_VAL"      );
         PORT_MAP(_component,src ,"out_ICACHE_RSP_ACK"      ,dest,"out_ICACHE_RSP_ACK"      );
         if (_param->_have_port_queue_ptr)
+        if (_param->_have_port_ifetch_queue_ptr)
         PORT_MAP(_component,src , "in_ICACHE_RSP_PACKET_ID",dest, "in_ICACHE_RSP_PACKET_ID");
         PORT_MAP(_component,src , "in_ICACHE_RSP_ERROR"    ,dest, "in_ICACHE_RSP_ERROR"    );
 …
+    {
       src = _name+"_ifetch_unit_glue";
       std::cout << "Instance : " << src << std::endl;
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
 …
     // ~~~~~[ Others ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (DEBUG_Ifetch_unit == true)
+      _component->test_map();
+#ifdef POSITION
+    _component->generate_file();
+#if DEBUG_Ifetch_unit == true
+    _component->test_map();
+#endif
+#ifdef POSITION
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/src/Ifetch_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Ifetch_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
 …
         delete     in_ICACHE_REQ_ACK                      ;
       //delete    out_ICACHE_REQ_THREAD_ID                ;
         if (_param->_have_port_queue_ptr)
+        if (_param->_have_port_ifetch_queue_ptr)
         delete    out_ICACHE_REQ_PACKET_ID                ;
         delete    out_ICACHE_REQ_ADDRESS                  ;
 …
         delete    out_ICACHE_RSP_ACK                      ;
       //delete     in_ICACHE_RSP_THREAD_ID                ;
         if (_param->_have_port_queue_ptr)
+        if (_param->_have_port_ifetch_queue_ptr)
         delete     in_ICACHE_RSP_PACKET_ID                ;
         delete []  in_ICACHE_RSP_INSTRUCTION              ;
 …
         delete     in_PREDICT_PC_NEXT_IS_DS_TAKE          ;
         delete []  in_PREDICT_INSTRUCTION_ENABLE          ;
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         delete     in_PREDICT_INST_IFETCH_PTR             ;
         delete     in_PREDICT_BRANCH_STATE                ;
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         delete     in_PREDICT_BRANCH_UPDATE_PREDICTION_ID ;
 …
       //delete    out_DECOD_CONTEXT_ID                    ;
         delete    out_DECOD_ADDRESS                       ;
         if (_param->_have_port_instruction_ptr)
+        if (_param->_have_port_inst_ifetch_ptr)
         delete    out_DECOD_INST_IFETCH_PTR               ;
         delete    out_DECOD_BRANCH_STATE                  ;
         if (_param->_have_port_branch_update_prediction_id)
+        if (_param->_have_port_depth)
         delete    out_DECOD_BRANCH_UPDATE_PREDICTION_ID   ;
         delete    out_DECOD_EXCEPTION                     ;
 …
         delete    out_EVENT_ACK                           ;
         delete     in_EVENT_ADDRESS                       ;
+        delete     in_EVENT_ADDRESS_NEXT                  ;
+        delete     in_EVENT_ADDRESS_NEXT_VAL              ;
+        delete     in_EVENT_IS_DS_TAKE                    ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/src/Ifetch_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/src/Parameters.cpp

-              r85
+              r88
                           uint32_t nb_instruction               ,
                           uint32_t size_branch_update_prediction,
+                          uint32_t size_address                 )
+                          uint32_t size_address                 ,
+                          bool     is_toplevel
+                          )
+  {
     log_printf(FUNC,Ifetch_unit,FUNCTION,"Begin");
 …
     _size_queue                            = size_queue                   ;
     _nb_instruction                        = nb_instruction               ;
+    _size_branch_update_prediction         = size_branch_update_prediction;
+    _size_address                          = size_address                 ;
+    _size_queue_ptr                        = log2(size_queue);
+    _size_instruction_ptr                  = log2(nb_instruction);
+    _have_port_queue_ptr                   = _size_queue_ptr > 0;
+    _have_port_instruction_ptr             = _size_instruction_ptr > 0;
+    _have_port_branch_update_prediction_id = size_branch_update_prediction > 0;
+//  _size_branch_update_prediction         = size_branch_update_prediction;
+//  _size_address                          = size_address                 ;
     test();
 …
     _param_ifetch_unit_glue   = new morpheo::behavioural::core::multi_front_end::front_end::ifetch_unit::ifetch_unit_glue::  Parameters
       (size_address);
+    if (is_toplevel)
+      {
+        _size_instruction_address   = size_address;
+        _size_ifetch_queue_ptr      = log2(size_queue);
+        _size_inst_ifetch_ptr       = log2(nb_instruction);
+        _size_depth                 = size_branch_update_prediction;
+        _have_port_ifetch_queue_ptr = _size_ifetch_queue_ptr > 0;
+        _have_port_inst_ifetch_ptr  = _size_inst_ifetch_ptr > 0;
+        _have_port_depth            = _size_depth > 0;
+        copy ();
+      }
     log_printf(FUNC,Ifetch_unit,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Ifetch_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Ifetch_unit,FUNCTION,"Begin");
+    COPY(_param_address_management);
+    COPY(_param_ifetch_queue      );
+    COPY(_param_ifetch_unit_glue  );
+    log_printf(FUNC,Ifetch_unit,FUNCTION,"End");
+  };
 }; // end namespace ifetch_unit
 }; // end namespace front_end

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/src/Parameters_print.cpp

-              r81
+              r88
     log_printf(FUNC,Ifetch_unit,FUNCTION,"Begin");
     XML xml ("ifetch_unit");
+//     XML xml ("ifetch_unit");
+    xml.balise_open("ifetch_unit");
+    xml.singleton_begin("size_queue                   "); xml.attribut("value",toString(_size_queue                   )); xml.singleton_end();
+    xml.singleton_begin("nb_instruction               "); xml.attribut("value",toString(_nb_instruction               )); xml.singleton_end();
+    xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
+    xml.singleton_begin("size_address                 "); xml.attribut("value",toString(_size_address                 )); xml.singleton_end();
+    xml.balise_close();
+//     xml.balise_open("ifetch_unit");
+//     xml.singleton_begin("size_queue                   "); xml.attribut("value",toString(_size_queue                   )); xml.singleton_end();
+//     xml.singleton_begin("nb_instruction               "); xml.attribut("value",toString(_nb_instruction               )); xml.singleton_end();
+// //  xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
+// //  xml.singleton_begin("size_address                 "); xml.attribut("value",toString(_size_address                 )); xml.singleton_end();
+//     xml.balise_close();
+//     return xml.get_body(depth);
+    std::string str = "";
     log_printf(FUNC,Ifetch_unit,FUNCTION,"End");
+    return str;
-    return xml.get_body(depth);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/SelfTest/Makefile

r81	r88
24	24	library_clean : Branch_Target_Buffer_Glue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_inst_predict    ,
          _nb_inst_decod      ,
+         _nb_inst_update     );
+         _nb_inst_update     ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Branch_Target_Buffer_Glue * _Branch_Target_Buffer_Glue = new Branch_Target_Buffer_Glue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/include/Parameters.h

-              r81
+              r88
   public : uint32_t   _size_buffer       ;
   public : uint32_t   _associativity     ;
   public : uint32_t   _size_address      ;
+//public : uint32_t   _size_address      ;
   public : uint32_t   _nb_inst_predict   ;
   public : uint32_t   _nb_inst_decod     ;
 …
                         uint32_t   nb_inst_predict   ,
                         uint32_t   nb_inst_decod     ,
+                        uint32_t   nb_inst_update    );
+                        uint32_t   nb_inst_update    ,
+                        bool       is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/src/Branch_Target_Buffer_Glue.cpp

-              r81
+              r88
     log_printf(FUNC,Branch_Target_Buffer_Glue,FUNCTION,"Begin");
+#if DEBUG_Branch_Target_Buffer_Glue == true
+    log_printf(INFO,Branch_Target_Buffer_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Branch_Target_Buffer_Glue,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Branch_Target_Buffer_Glue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 # if defined(STATISTICS) or defined(VHDL_TESTBENCH)
 …
+          }
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
         for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+          {
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_HIT            [i])) (*(in_PREDICT_REGISTER_HIT          [i][j]));
             if (_param->_have_port_victim)
             (*(out_PREDICT_HIT            [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_ADDRESS_SRC    [i])) (*(in_PREDICT_REGISTER_ADDRESS_SRC  [i][j]));
             if (_param->_have_port_victim)
             (*(out_PREDICT_ADDRESS_SRC    [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_ADDRESS_DEST   [i])) (*(in_PREDICT_REGISTER_ADDRESS_DEST [i][j]));
             if (_param->_have_port_victim)
             (*(out_PREDICT_ADDRESS_DEST   [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_CONDITION      [i])) (*(in_PREDICT_REGISTER_CONDITION    [i][j]));
             if (_param->_have_port_victim)
             (*(out_PREDICT_CONDITION      [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_LAST_TAKE      [i])) (*(in_PREDICT_REGISTER_LAST_TAKE    [i][j]));
             if (_param->_have_port_victim)
             (*(out_PREDICT_LAST_TAKE      [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_IS_ACCURATE    [i])) (*(in_PREDICT_REGISTER_IS_ACCURATE  [i][j]));
             if (_param->_have_port_victim)
             (*(out_PREDICT_IS_ACCURATE    [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             (*(out_PREDICT_ACK            [i])) (*(in_PREDICT_REGISTER_ACK          [i]));
             if (_param->_have_port_victim)
+              {
             (*(out_PREDICT_ACK            [i])) (*(in_PREDICT_SORT_VAL              [i]));
             (*(out_PREDICT_ACK            [i])) (*(in_PREDICT_VICTIM_ACK            [i]));
+              }
             (*(out_PREDICT_REGISTER_VAL   [i])) (*(in_PREDICT_VAL                   [i]));
             if (_param->_have_port_victim)
+              {
             (*(out_PREDICT_REGISTER_VAL   [i])) (*(in_PREDICT_SORT_VAL              [i]));
             (*(out_PREDICT_REGISTER_VAL   [i])) (*(in_PREDICT_VICTIM_ACK            [i]));
+              }
             if (_param->_have_port_victim)
+              {
             (*(out_PREDICT_VICTIM_VAL     [i])) (*(in_PREDICT_VAL                   [i]));
             (*(out_PREDICT_VICTIM_VAL     [i])) (*(in_PREDICT_REGISTER_ACK          [i]));
             (*(out_PREDICT_VICTIM_VAL     [i])) (*(in_PREDICT_SORT_VAL              [i]));
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_VICTIM_HIT     [i])) (*(in_PREDICT_REGISTER_HIT          [i][j]));
             (*(out_PREDICT_VICTIM_HIT     [i])) (*(in_PREDICT_SORT_INDEX            [i]));
             if (not _param->_is_full_associative)
+              {
             for (uint32_t j=0; j<_param->_associativity; j++)
             (*(out_PREDICT_VICTIM_ADDRESS [i])) (*(in_PREDICT_REGISTER_ADDRESS_SRC  [i][j]));
             (*(out_PREDICT_VICTIM_ADDRESS [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+              }
             (*(out_PREDICT_VICTIM_INDEX   [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+              }
+          }
 # endif
+// # ifdef SYSTEMCASS_SPECIFIC
+//      // List dependency information
+//      for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+//        {
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_HIT            [i])) (*(in_PREDICT_REGISTER_HIT          [i][j]));
+//          if (_param->_have_port_victim)
+//          (*(out_PREDICT_HIT            [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_ADDRESS_SRC    [i])) (*(in_PREDICT_REGISTER_ADDRESS_SRC  [i][j]));
+//          if (_param->_have_port_victim)
+//          (*(out_PREDICT_ADDRESS_SRC    [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_ADDRESS_DEST   [i])) (*(in_PREDICT_REGISTER_ADDRESS_DEST [i][j]));
+//          if (_param->_have_port_victim)
+//          (*(out_PREDICT_ADDRESS_DEST   [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_CONDITION      [i])) (*(in_PREDICT_REGISTER_CONDITION    [i][j]));
+//          if (_param->_have_port_victim)
+//          (*(out_PREDICT_CONDITION      [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_LAST_TAKE      [i])) (*(in_PREDICT_REGISTER_LAST_TAKE    [i][j]));
+//          if (_param->_have_port_victim)
+//          (*(out_PREDICT_LAST_TAKE      [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_IS_ACCURATE    [i])) (*(in_PREDICT_REGISTER_IS_ACCURATE  [i][j]));
+//          if (_param->_have_port_victim)
+//          (*(out_PREDICT_IS_ACCURATE    [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          (*(out_PREDICT_ACK            [i])) (*(in_PREDICT_REGISTER_ACK          [i]));
+//          if (_param->_have_port_victim)
+//            {
+//          (*(out_PREDICT_ACK            [i])) (*(in_PREDICT_SORT_VAL              [i]));
+//          (*(out_PREDICT_ACK            [i])) (*(in_PREDICT_VICTIM_ACK            [i]));
+//            }
+//          (*(out_PREDICT_REGISTER_VAL   [i])) (*(in_PREDICT_VAL                   [i]));
+//          if (_param->_have_port_victim)
+//            {
+//          (*(out_PREDICT_REGISTER_VAL   [i])) (*(in_PREDICT_SORT_VAL              [i]));
+//          (*(out_PREDICT_REGISTER_VAL   [i])) (*(in_PREDICT_VICTIM_ACK            [i]));
+//            }
+//          if (_param->_have_port_victim)
+//            {
+//          (*(out_PREDICT_VICTIM_VAL     [i])) (*(in_PREDICT_VAL                   [i]));
+//          (*(out_PREDICT_VICTIM_VAL     [i])) (*(in_PREDICT_REGISTER_ACK          [i]));
+//          (*(out_PREDICT_VICTIM_VAL     [i])) (*(in_PREDICT_SORT_VAL              [i]));
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_VICTIM_HIT     [i])) (*(in_PREDICT_REGISTER_HIT          [i][j]));
+//          (*(out_PREDICT_VICTIM_HIT     [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//          if (not _param->_is_full_associative)
+//            {
+//          for (uint32_t j=0; j<_param->_associativity; j++)
+//          (*(out_PREDICT_VICTIM_ADDRESS [i])) (*(in_PREDICT_REGISTER_ADDRESS_SRC  [i][j]));
+//          (*(out_PREDICT_VICTIM_ADDRESS [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//            }
+//          (*(out_PREDICT_VICTIM_INDEX   [i])) (*(in_PREDICT_SORT_INDEX            [i]));
+//            }
+//        }
+// # endif
         log_printf(INFO,Branch_Target_Buffer_Glue,FUNCTION,"Method - genMealy_decod");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/src/Branch_Target_Buffer_Glue_allocation.cpp

-              r81
+              r88
         ALLOC1_SIGNAL_OUT(out_PREDICT_ACK           , "ack"           ,Tcontrol_t         , 1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_HIT           , "hit"           ,Tcontrol_t         , 1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC   , "address_src"   ,Tgeneral_data_t    , _param->_size_address);
         ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST  , "address_dest"  ,Tgeneral_data_t    , _param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC   , "address_src"   ,Tgeneral_data_t    , _param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST  , "address_dest"  ,Tgeneral_data_t    , _param->_size_instruction_address);
         ALLOC1_SIGNAL_OUT(out_PREDICT_CONDITION     , "condition"     ,Tbranch_condition_t, _param->_size_branch_condition);
         ALLOC1_SIGNAL_OUT(out_PREDICT_LAST_TAKE     , "last_take"     ,Tcontrol_t         , 1);
 …
         ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_HIT         ,"register_hit"         ,Tcontrol_t         ,1);
         ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_ADDRESS_SRC ,"register_address_src" ,Tgeneral_data_t    ,_param->_size_address);
         ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_ADDRESS_DEST,"register_address_dest",Tgeneral_data_t    ,_param->_size_address);
+        ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_ADDRESS_SRC ,"register_address_src" ,Tgeneral_data_t    ,_param->_size_instruction_address);
+        ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_ADDRESS_DEST,"register_address_dest",Tgeneral_data_t    ,_param->_size_instruction_address);
         ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_CONDITION   ,"register_condition"   ,Tbranch_condition_t,_param->_size_branch_condition);
         ALLOC2_SIGNAL_IN ( in_PREDICT_REGISTER_LAST_TAKE   ,"register_last_take"   ,Tcontrol_t         ,1);
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_ACK           ,"ack"           ,Tcontrol_t     ,1);
       if (not _param->_is_full_associative)
       ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_SRC   ,"address_src"   ,Tgeneral_data_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_SRC   ,"address_src"   ,Tgeneral_data_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_DECOD_REGISTER_VAL  ,"register_val"  ,Tcontrol_t     ,1);
 …
       ALLOC1_SIGNAL_OUT(out_UPDATE_ACK           ,"ack"           ,Tcontrol_t     ,1);
       if (not _param->_is_full_associative)
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_SRC   ,"address_src"   ,Tgeneral_data_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_SRC   ,"address_src"   ,Tgeneral_data_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_UPDATE_REGISTER_VAL  ,"register_val"  ,Tcontrol_t     ,1);
 …
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/src/Branch_Target_Buffer_Glue_deallocation.cpp

r81	r88
24	24	log_printf(FUNC,Branch_Target_Buffer_Glue,FUNCTION,"Begin");
25	25
26		if (~~_usage & USE_SYSTEMC~~)
	26	if (usage_is_set(_usage,USE_SYSTEMC))
27	27	{
28	28	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/src/Branch_Target_Buffer_Glue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_inst_predict   ,
                           uint32_t   nb_inst_decod     ,
+                          uint32_t   nb_inst_update    )
+                          uint32_t   nb_inst_update    ,
+                          bool       is_toplevel)
+  {
     log_printf(FUNC,Branch_Target_Buffer_Glue,FUNCTION,"Begin");
 …
     _size_buffer            = size_buffer       ;
     _associativity          = associativity     ;
     _size_address           = size_address      ;
+//  _size_address           = size_address      ;
     _nb_inst_predict        = nb_inst_predict   ;
     _nb_inst_decod          = nb_inst_decod     ;
 …
     test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address;
+        copy();
+      }
     log_printf(FUNC,Branch_Target_Buffer_Glue,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Branch_Target_Buffer_Glue::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Branch_Target_Buffer_Glue,FUNCTION,"Begin");
+    log_printf(FUNC,Branch_Target_Buffer_Glue,FUNCTION,"End");
+  };
 }; // end namespace branch_target_buffer_glue
 }; // end namespace branch_target_buffer

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue/src/Parameters_print.cpp

r81	r88
31	31	xml.singleton_begin("size_buffer "); xml.attribut("value",toString(_size_buffer )); xml.singleton_end();
32	32	xml.singleton_begin("associativity "); xml.attribut("value",toString(_associativity )); xml.singleton_end();
33		xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
	33	// xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
34	34	xml.singleton_begin("nb_inst_predict "); xml.attribut("value",toString(_nb_inst_predict )); xml.singleton_end();
35	35	xml.singleton_begin("nb_inst_decod "); xml.attribut("value",toString(_nb_inst_decod )); xml.singleton_end();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/Makefile.deps

-              r81
+              r88
 #-----[ Directory ]----------------------------------------
 Branch_Target_Buffer_Register_DIR                       =       $(DIR_MORPHEO)/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register
+Branch_Target_Buffer_Register_DIR               =       $(DIR_MORPHEO)/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register
 #-----[ Library ]------------------------------------------
 Branch_Target_Buffer_Register_LIBRARY           =       -lBranch_Target_Buffer_Register \
                                         $(Behavioural_LIBRARY)
+                                                        $(Behavioural_LIBRARY)
 Branch_Target_Buffer_Register_DIR_LIBRARY               =       -L$(Branch_Target_Buffer_Register_DIR)/lib      \
                                         $(Behavioural_DIR_LIBRARY)
+Branch_Target_Buffer_Register_DIR_LIBRARY       =       -L$(Branch_Target_Buffer_Register_DIR)/lib      \
+                                                        $(Behavioural_DIR_LIBRARY)
 #-----[ Rules ]--------------------------------------------

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/Makefile

r81	r88
24	24	library_clean : Branch_Target_Buffer_Register_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/config_min.cfg

r82	r88
4	4	1 1 *4 # size_buffer
5	5	1 1 *4 # associativity
6		3~~2 32~~ *2 # size_address
	6	30 30 *2 # size_address
7	7	2 2 +1 # size_counter
8	8	1 1 *4 # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/config_mono_context.cfg

r81	r88
4	4	16 16 *4 # size_buffer
5	5	2 16 *4 # associativity
6		3~~2 32~~ *2 # size_address
	6	30 30 *2 # size_address
7	7	2 2 +1 # size_counter
8	8	1 4 *4 # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/config_multi_context.cfg

r81	r88
7	7	8 64 *4 # size_buffer
8	8	4 8 *2 # associativity
9		3~~2 32~~ *2 # size_address
	9	30 30 *2 # size_address
10	10	2 2 +1 # size_counter
11	11	1 4 *4 # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_inst_predict,
          _nb_inst_decod  ,
+         _nb_inst_commit );
+         _nb_inst_commit ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/src/test.cpp

-              r82
+              r88
 #include "Common/include/BitManipulation.h"
 #include "Behavioural/include/Allocation.h"
+  class entry_t
+  {
+  public : Tcontrol_t          _val             ;
+  public : Tcontext_t          _context         ;
+  public : Tcontrol_t          _address_dest_val;
+  public : Tgeneral_data_t     _address_src     ;
+  public : Tgeneral_data_t     _address_dest    ;
+  public : Tbranch_condition_t _condition       ;
+  public : Tcontrol_t          _last_take       ;
+  public : Tcounter_t          _accurate        ;
+  public : bool hit (morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::branch_target_buffer::branch_target_buffer_register::Parameters * _param,
+                     Tgeneral_data_t addr_test,
+                     Tcontext_t      context)
+    {
+      Tgeneral_data_t addr_src_offset  = (_address_src  >> _param->_shift_offset)&_param->_mask_offset;
+      Tgeneral_data_t addr_src_index   = (_address_src  >> _param->_shift_bank  )&_param->_mask_bank  ;
+      Tgeneral_data_t addr_src_tag     = (_address_src  >> _param->_shift_tag   );
+      Tgeneral_data_t addr_test_offset = (addr_test >> _param->_shift_offset)&_param->_mask_offset;
+      Tgeneral_data_t addr_test_index  = (addr_test >> _param->_shift_bank  )&_param->_mask_bank  ;
+      Tgeneral_data_t addr_test_tag    = (addr_test >> _param->_shift_tag   );
+      bool is_hit = ( (_val             == 1               ) and
+                      (_context         == context         ) and
+                      (addr_test_tag    == addr_src_tag    ) and
+                      (addr_test_index  == addr_src_index  ) and
+                      (addr_test_offset <= addr_src_offset ));
+      LABEL("address_src  (tag, index, offset) : %.8x %.8x %.8x",addr_src_tag, addr_src_index, addr_src_offset);
+      LABEL("address_test (tag, index, offset) : %.8x %.8x %.8x - hit : %d",addr_test_tag, addr_test_index, addr_test_offset, is_hit);
+      return is_hit;
+    }
+  public : void print (void)
+    {
+      LABEL("%d - %.2d %.8x %.1d %.8x %.3d %.1d %.4d",
+            _val             ,
+            _context         ,
+            _address_src     ,
+            _address_dest_val,
+            _address_dest    ,
+            _condition       ,
+            _last_take       ,
+            _accurate        );
+    }
+  };
+Tgeneral_data_t gen_addr (morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::branch_target_buffer::branch_target_buffer_register::Parameters * _param,
+                          Tgeneral_data_t index)
+{
+  Tgeneral_data_t addr_tag     = (rand()%(2*_param->_associativity)) << _param->_shift_tag   ;
+  Tgeneral_data_t addr_index   = (index &_param->_mask_bank        ) << _param->_shift_bank  ;
+  Tgeneral_data_t addr_offset  = (rand()&_param->_mask_offset      ) << _param->_shift_offset;
+  LABEL("gen_addr     (tag, index, offset) : %.8x %.8x %.8x",addr_tag, addr_index, addr_offset);
+  return (addr_tag    |
+          addr_index  |
+          addr_offset );
+}
+#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/include/test_BTB.h"
 void test (string name,
 …
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Branch_Target_Buffer_Register * _Branch_Target_Buffer_Register = new Branch_Target_Buffer_Register
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
           in_DECOD_VICTIM          [i]->write(rand()%_param->_associativity);
           in_DECOD_CONTEXT_ID      [i]->write(rand()%_param->_nb_context);
           in_DECOD_ADDRESS_SRC     [i]->write(addr);
+          in_DECOD_ADDRESS_SRC     [i]->write( addr);
           in_DECOD_ADDRESS_DEST    [i]->write(~addr);
           in_DECOD_CONDITION       [i]->write((addr&1)?BRANCH_CONDITION_FLAG_SET:BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK);
 …
           in_UPDATE_VICTIM          [i]->write(rand()%_param->_associativity);
           in_UPDATE_CONTEXT_ID      [i]->write(rand()%_param->_nb_context);
           in_UPDATE_ADDRESS_SRC     [i]->write(addr);
+          in_UPDATE_ADDRESS_SRC     [i]->write( addr);
           in_UPDATE_ADDRESS_DEST    [i]->write(~addr);
           in_UPDATE_CONDITION       [i]->write((addr&1)?BRANCH_CONDITION_FLAG_SET:BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK);
 …
             bool hit = false;
+            for (uint32_t j=0; j<_param->_associativity; j++)
+              hit |= ((tab_old[j]._val         == 1) and
+                      (tab_old[j]._context     == in_DECOD_CONTEXT_ID  [i]->read()) and
+                      (tab_old[j]._address_src == in_DECOD_ADDRESS_SRC [i]->read()));
+            Tptr_t k;
+            for (k=0; k<_param->_associativity; k++)
+              {
+                hit |= ((tab_old[k]._val         == 1) and
+                        (tab_old[k]._context     == in_DECOD_CONTEXT_ID  [i]->read()) and
+                        (tab_old[k]._address_src == in_DECOD_ADDRESS_SRC [i]->read()));
+                if (hit)
+                  break;
+              }
             if (not hit)
+              {
+                Tptr_t k = in_DECOD_VICTIM [i]->read();
+                k = in_DECOD_VICTIM [i]->read();
                 LABEL("  * miss");
                 LABEL("  * victim      : %d",k);
 …
                 tab[k]._condition        = in_DECOD_CONDITION   [i]->read();
                 tab[k]._last_take        = in_DECOD_LAST_TAKE   [i]->read();
                 //tab[k]._accurate         = _param->_first_accurate_if_hit;
+                tab[k]._accurate         =(in_DECOD_IS_ACCURATE [i]->read())?_param->_first_accurate_if_hit:_param->_first_accurate_if_miss;
+              }
             else
+              {
+                LABEL("  * miss");
+              }
+            TEST(Tcontrol_t, out_DECOD_HIT [i]->read(), hit);
+                LABEL("  * hit");
+              }
+            if (_param->_have_port_victim)
+              {
+            TEST(Tcontrol_t, out_DECOD_HIT       [i]->read(), hit);
+            if (hit)
+            TEST(Tptr_t    , out_DECOD_HIT_INDEX [i]->read(), k);
+              }
+          }
 …
             bool hit = false;
             Tptr_t k = 0;
             for (uint32_t j=0; j<_param->_associativity; j++)
+              {
                 hit |= ((tab_old[j]._val         == 1) and
                         (tab_old[j]._context     == in_UPDATE_CONTEXT_ID  [i]->read()) and
                         (tab_old[j]._address_src == in_UPDATE_ADDRESS_SRC [i]->read()));
+            Tptr_t k;
+            for (k=0; k<_param->_associativity; k++)
+              {
+                hit |= ((tab_old[k]._val         == 1) and
+                        (tab_old[k]._context     == in_UPDATE_CONTEXT_ID  [i]->read()) and
+                        (tab_old[k]._address_src == in_UPDATE_ADDRESS_SRC [i]->read()));
                 if (hit)
+                  {
+                    k = j;
+                    break;
+                  }
+                  break;
+              }
 …
                 tab[k]._condition        = in_UPDATE_CONDITION   [i]->read();
                 tab[k]._last_take        = in_UPDATE_LAST_TAKE   [i]->read();
                 //tab[k]._accurate         = (in_UPDATE_MISS_PREDICTION [i]->read())?_param->_first_accurate_if_miss:_param->_first_accurate_if_hit;
+                tab[k]._accurate         = (in_UPDATE_MISS_PREDICTION [i]->read())?_param->_first_accurate_if_miss:_param->_first_accurate_if_hit;
+              }
             else
 …
                 tab[k]._condition        = in_UPDATE_CONDITION   [i]->read();
                 tab[k]._last_take        = in_UPDATE_LAST_TAKE   [i]->read();
+                //tab[k]._accurate         = (in_UPDATE_MISS_PREDICTION [i]->read())?_param->_first_accurate_if_miss:_param->_first_accurate_if_hit;
+              }
+            TEST(Tcontrol_t, out_UPDATE_HIT [i]->read(), hit);
+                Tcounter_t accurate_old = tab[k]._accurate;
+                // hit  : increase accurate
+                // miss : decrease accurate
+                Tcounter_t accurate_new = (in_UPDATE_MISS_PREDICTION [i]->read())?((accurate_old>0)?(accurate_old-1):accurate_old):((accurate_old<_param->_accurate_max)?(accurate_old+1):accurate_old);
+                // test if accurate go to the threshold
+                if ((accurate_old >= _param->_accurate_limit) and
+                    (accurate_new <  _param->_accurate_limit))
+                  accurate_new = 0;
+                tab[k]._accurate         = accurate_new;
+              }
+            if (_param->_have_port_victim)
+              {
+            TEST(Tcontrol_t, out_UPDATE_HIT       [i]->read(), hit);
+            if (hit)
+            TEST(Tptr_t    , out_UPDATE_HIT_INDEX [i]->read(), k);
+              }
+          }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/include/Parameters.h

-              r81
+              r88
   public : uint32_t   _size_buffer    ;
   public : uint32_t   _associativity  ;
   public : uint32_t   _size_address   ;
+//public : uint32_t   _size_address   ;
   public : uint32_t   _size_counter   ;
   public : uint32_t   _nb_inst_predict;
 …
   public : uint32_t   _size_bank      ;
   public : uint32_t   _size_context_id;
+//public : uint32_t   _size_context_id;
   public : uint32_t   _size_victim    ;
   public : bool       _have_port_context_id;
+//public : bool       _have_port_context_id;
   public : bool       _have_port_victim    ;
 …
                         uint32_t   nb_inst_predict,
                         uint32_t   nb_inst_decod  ,
+                        uint32_t   nb_inst_update );
+                        uint32_t   nb_inst_update ,
+                        bool       is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register.cpp

-              r82
+              r88
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
+#if DEBUG_Branch_Target_Buffer_Register == true
+    log_printf(INFO,Branch_Target_Buffer_Register,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Branch_Target_Buffer_Register,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Branch_Target_Buffer_Register,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         // Constant
 …
+          }
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
         for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
           for (uint32_t j=0; j<_param->_associativity; j++)
+            {
               (*(out_PREDICT_HIT          [i][j])) (*(in_PREDICT_ADDRESS    [i]));
               if (_param->_have_port_context_id)
               (*(out_PREDICT_HIT          [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
               (*(out_PREDICT_ADDRESS_SRC  [i][j])) (*(in_PREDICT_ADDRESS    [i]));
               if (_param->_have_port_context_id)
               (*(out_PREDICT_ADDRESS_SRC  [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
               (*(out_PREDICT_ADDRESS_DEST [i][j])) (*(in_PREDICT_ADDRESS    [i]));
               if (_param->_have_port_context_id)
               (*(out_PREDICT_ADDRESS_DEST [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
               (*(out_PREDICT_CONDITION    [i][j])) (*(in_PREDICT_ADDRESS    [i]));
               if (_param->_have_port_context_id)
               (*(out_PREDICT_CONDITION    [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
               (*(out_PREDICT_LAST_TAKE    [i][j])) (*(in_PREDICT_ADDRESS    [i]));
               if (_param->_have_port_context_id)
               (*(out_PREDICT_LAST_TAKE    [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
               (*(out_PREDICT_IS_ACCURATE  [i][j])) (*(in_PREDICT_ADDRESS    [i]));
               if (_param->_have_port_context_id)
               (*(out_PREDICT_IS_ACCURATE  [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+          }
 # endif
+// # ifdef SYSTEMCASS_SPECIFIC
+//      // List dependency information
+//      for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+//        for (uint32_t j=0; j<_param->_associativity; j++)
+//          {
+//            (*(out_PREDICT_HIT          [i][j])) (*(in_PREDICT_ADDRESS    [i]));
+//            if (_param->_have_port_context_id)
+//            (*(out_PREDICT_HIT          [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+//            (*(out_PREDICT_ADDRESS_SRC  [i][j])) (*(in_PREDICT_ADDRESS    [i]));
+//            if (_param->_have_port_context_id)
+//            (*(out_PREDICT_ADDRESS_SRC  [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+//            (*(out_PREDICT_ADDRESS_DEST [i][j])) (*(in_PREDICT_ADDRESS    [i]));
+//            if (_param->_have_port_context_id)
+//            (*(out_PREDICT_ADDRESS_DEST [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+//            (*(out_PREDICT_CONDITION    [i][j])) (*(in_PREDICT_ADDRESS    [i]));
+//            if (_param->_have_port_context_id)
+//            (*(out_PREDICT_CONDITION    [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+//            (*(out_PREDICT_LAST_TAKE    [i][j])) (*(in_PREDICT_ADDRESS    [i]));
+//            if (_param->_have_port_context_id)
+//            (*(out_PREDICT_LAST_TAKE    [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+//            (*(out_PREDICT_IS_ACCURATE  [i][j])) (*(in_PREDICT_ADDRESS    [i]));
+//            if (_param->_have_port_context_id)
+//            (*(out_PREDICT_IS_ACCURATE  [i][j])) (*(in_PREDICT_CONTEXT_ID [i]));
+//        }
+// # endif
         if (_param->_have_port_victim)
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_allocation.cpp

-              r82
+              r88
       ALLOC1_VALACK_OUT(out_PREDICT_ACK         ,ACK);
       ALLOC1_SIGNAL_IN ( in_PREDICT_CONTEXT_ID  ,"context_id"  ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS     ,"address"     ,Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS     ,"address"     ,Tgeneral_data_t    ,_param->_size_instruction_address);
+      {
 …
         ALLOC2_SIGNAL_OUT(out_PREDICT_HIT         ,"hit"         ,Tcontrol_t         ,1);
         ALLOC2_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC ,"address_src" ,Tgeneral_data_t    ,_param->_size_address);
         ALLOC2_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST,"address_dest",Tgeneral_data_t    ,_param->_size_address);
+        ALLOC2_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC ,"address_src" ,Tgeneral_data_t    ,_param->_size_instruction_address);
+        ALLOC2_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST,"address_dest",Tgeneral_data_t    ,_param->_size_instruction_address);
         ALLOC2_SIGNAL_OUT(out_PREDICT_CONDITION   ,"condition"   ,Tbranch_condition_t,_param->_size_branch_state);
         ALLOC2_SIGNAL_OUT(out_PREDICT_LAST_TAKE   ,"last_take"   ,Tcontrol_t         ,1);
 …
+        }
       ALLOC1_SIGNAL_IN ( in_DECOD_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_state);
       ALLOC1_SIGNAL_IN ( in_DECOD_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
 …
+        }
       ALLOC1_SIGNAL_IN ( in_UPDATE_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_state);
       ALLOC1_SIGNAL_IN ( in_UPDATE_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
 …
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     reg_BTB = new btb_entry_t * [_param->_size_bank];
 …
     internal_UPDATE_NUM_BANK  = new uint32_t   [_param->_nb_inst_update];
     internal_UPDATE_NUM_ENTRY = new uint32_t   [_param->_nb_inst_update];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_deallocation.cpp

-              r82
+              r88
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         delete []  in_DECOD_VAL             ;
         delete [] out_DECOD_ACK             ;
+        if (_param->_have_port_victim)
+          {
         delete [] out_DECOD_HIT             ;
-        if (_param->_have_port_victim)
         delete [] out_DECOD_HIT_INDEX       ;
-        if (_param->_have_port_victim)
         delete []  in_DECOD_VICTIM          ;
+          }
         if (_param->_have_port_context_id)
         delete []  in_DECOD_CONTEXT_ID      ;
 …
         delete []  in_UPDATE_VAL            ;
         delete [] out_UPDATE_ACK            ;
+        if (_param->_have_port_victim)
+          {
         delete [] out_UPDATE_HIT            ;
-        if (_param->_have_port_victim)
         delete [] out_UPDATE_HIT_INDEX      ;
-        if (_param->_have_port_victim)
         delete []  in_UPDATE_VICTIM         ;
+          }
         if (_param->_have_port_context_id)
         delete []  in_UPDATE_CONTEXT_ID     ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_genMealy_decod.cpp

-              r82
+              r88
   void Branch_Target_Buffer_Register::genMealy_decod (void)
+  {
+    log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
+    log_begin(Branch_Target_Buffer_Register,FUNCTION);
+    log_function(Branch_Target_Buffer_Register,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
 …
+      }
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");
+    log_end(Branch_Target_Buffer_Register,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_genMealy_predict.cpp

-              r81
+              r88
   void Branch_Target_Buffer_Register::genMealy_predict (void)
+  {
+    log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
+    log_begin(Branch_Target_Buffer_Register,FUNCTION);
+    log_function(Branch_Target_Buffer_Register,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+      {
+        log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"  * PREDICT [%d]",i);
         Tcontext_t      context   = (_param->_have_port_context_id)?PORT_READ(in_PREDICT_CONTEXT_ID  [i]):0;
         Tgeneral_data_t address   = PORT_READ(in_PREDICT_ADDRESS [i]);
 …
         Tgeneral_data_t address_offset = (address >> _param->_shift_offset)&_param->_mask_offset;
 //      log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"address_    (tag, bank, offset) : %.8x %.8x %.8x",address_tag,num_bank, address_offset);
+        log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"    * address_    (tag, bank, offset) : %.8x %.8x %.8x",address_tag,num_bank, address_offset);
         for (uint32_t j=0; j<_param->_associativity; j++)
 …
                               (address_src_offset                >= address_offset));
 //          log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"address_src (tag, bank, offset) : %.8x %.8x %.8x - hit : %d",address_src_tag,num_bank,address_src_offset, hit);
+            log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"    * address_src (tag, bank, offset) : %.8x %.8x %.8x - hit : %d",address_src_tag,num_bank,address_src_offset, hit);
             // Hit :
 …
+      }
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");
+    log_end(Branch_Target_Buffer_Register,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_genMealy_update.cpp

-              r82
+              r88
   void Branch_Target_Buffer_Register::genMealy_update (void)
+  {
+    log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
+    log_begin(Branch_Target_Buffer_Register,FUNCTION);
+    log_function(Branch_Target_Buffer_Register,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_update; i++)
 …
+      }
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");
+    log_end(Branch_Target_Buffer_Register,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Branch_Target_Buffer_Register_transition.cpp

-              r82
+              r88
   void Branch_Target_Buffer_Register::transition (void)
+  {
+    log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
+    log_begin(Branch_Target_Buffer_Register,FUNCTION);
+    log_function(Branch_Target_Buffer_Register,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
           if (PORT_READ(in_UPDATE_VAL [i]) and internal_UPDATE_ACK [i])
+            {
+              log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"  * UPDATE [%d]",i);
               bool     hit       = internal_UPDATE_HIT      [i];
               uint32_t num_bank  = internal_UPDATE_NUM_BANK [i];
 …
               // detect new branch !!! insert in branch target buffer
+              log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"    * hit       : %d",hit);
+              log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"    * num_bank  : %d",num_bank );
+              log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"    * num_entry : %d",num_entry);
               Tcounter_t accurate_new = 0;
 …
                   accurate_new =  (miss_pred)?_param->_first_accurate_if_miss:_param->_first_accurate_if_hit;
+                  reg_BTB[num_bank][num_entry]._val              = 1;
+                  reg_BTB[num_bank][num_entry]._context          = (_param->_have_port_context_id)?PORT_READ(in_UPDATE_CONTEXT_ID [i]):0;
+                  reg_BTB[num_bank][num_entry]._address_src      = PORT_READ(in_UPDATE_ADDRESS_SRC  [i]);
+                  reg_BTB[num_bank][num_entry]._condition        = PORT_READ(in_UPDATE_CONDITION    [i]);
+                  reg_BTB[num_bank][num_entry]._last_take        = PORT_READ(in_UPDATE_LAST_TAKE    [i]);
+                }
+//                reg_BTB[num_bank][num_entry]._val              = 1;
+//                reg_BTB[num_bank][num_entry]._context          = (_param->_have_port_context_id)?PORT_READ(in_UPDATE_CONTEXT_ID [i]):0;
+//                reg_BTB[num_bank][num_entry]._address_src      = PORT_READ(in_UPDATE_ADDRESS_SRC  [i]);
+//                reg_BTB[num_bank][num_entry]._condition        = PORT_READ(in_UPDATE_CONDITION    [i]);
+//                reg_BTB[num_bank][num_entry]._last_take        = PORT_READ(in_UPDATE_LAST_TAKE    [i]);
+                  reg_BTB[num_bank][num_entry]._address_dest_val = 0;
+                }
               // =====[ All Case ]
+              if (reg_BTB[num_bank][num_entry]._address_dest_val == 0)
+                {
+                  reg_BTB[num_bank][num_entry]._address_dest_val = 1;
+                  reg_BTB[num_bank][num_entry]._address_dest     = PORT_READ(in_UPDATE_ADDRESS_DEST [i]);
+                }
+//            if (reg_BTB[num_bank][num_entry]._address_dest_val == 0)
+//              {
+//                reg_BTB[num_bank][num_entry]._address_dest_val = 1;
+//                reg_BTB[num_bank][num_entry]._address_dest     = PORT_READ(in_UPDATE_ADDRESS_DEST [i]);
+//              }
+              reg_BTB[num_bank][num_entry]._val              = 1;
+              reg_BTB[num_bank][num_entry]._context          = (_param->_have_port_context_id)?PORT_READ(in_UPDATE_CONTEXT_ID [i]):0;
+              reg_BTB[num_bank][num_entry]._address_src      = PORT_READ(in_UPDATE_ADDRESS_SRC  [i]);
+              reg_BTB[num_bank][num_entry]._condition        = PORT_READ(in_UPDATE_CONDITION    [i]);
+              reg_BTB[num_bank][num_entry]._last_take        = PORT_READ(in_UPDATE_LAST_TAKE    [i]);
+              reg_BTB[num_bank][num_entry]._address_dest_val = 1;
+              reg_BTB[num_bank][num_entry]._address_dest     = PORT_READ(in_UPDATE_ADDRESS_DEST [i]);
               reg_BTB[num_bank][num_entry]._accurate         = accurate_new;
+            }
+#if (DEBUG >= DEBUG_TRACE) and DEBUG_Branch_Target_Buffer_Register
+        log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"  * Dump BTB");
         for (uint32_t i=0; i<_param->_size_bank; i++)
           for (uint32_t j=0; j<_param->_associativity; j++)
             log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"[%.4d][%.4d] %d - %.2d %.8x %.1d %.8x %.3d %.1d %.4d",
+            log_printf(TRACE,Branch_Target_Buffer_Register,FUNCTION,"    [%.4d][%.4d] %d - %.4d %.8x (%.8x) %.1d %.8x (%.8x) %.3d %.1d %.4d",
                        i,j,
                        reg_BTB [i][j]._val             ,
                        reg_BTB [i][j]._context         ,
                        reg_BTB [i][j]._address_src     ,
+                       reg_BTB [i][j]._address_src <<2,
                        reg_BTB [i][j]._address_dest_val,
                        reg_BTB [i][j]._address_dest    ,
+                       reg_BTB [i][j]._address_dest<<2 ,
                        reg_BTB [i][j]._condition       ,
                        reg_BTB [i][j]._last_take       ,
                        reg_BTB [i][j]._accurate        );
+#endif
+      }
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     end_cycle ();
 #endif
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");
+    log_end(Branch_Target_Buffer_Register,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_inst_predict,
                           uint32_t   nb_inst_decod  ,
+                          uint32_t   nb_inst_update )
+                          uint32_t   nb_inst_update ,
+                          bool       is_toplevel)
+  {
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
 …
     _size_buffer     = size_buffer    ;
     _associativity   = associativity  ;
-    _size_address    = size_address   ;
     _size_counter    = size_counter   ;
     _nb_inst_predict = nb_inst_predict;
 …
     _size_bank       = size_buffer/associativity;
-    _size_context_id = log2(nb_context);
     _size_victim     = log2(associativity);
-    _have_port_context_id   = (_size_context_id > 0);
     _have_port_victim       = (_size_victim     > 0);
 …
     test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address   ;
+        _size_context_id          = log2(nb_context);
+        _have_port_context_id     = (_size_context_id > 0);
+        copy ();
+      }
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Branch_Target_Buffer_Register::copy"
+  void Parameters::copy ()
+  {
+    log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"Begin");
+    log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");
+  };
 }; // end namespace branch_target_buffer_register
 }; // end namespace branch_target_buffer

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Parameters_msg_error.cpp

-              r81
+              r88
     if (_size_counter < 2 )
       test.error("size_counter must be >= 2.");
+      test.error(_("size_counter must be >= 2.\n"));
     if ((_associativity == 0) or
         (_associativity > _size_buffer))
       test.error("associativity must be > 0 and <= size_buffer.");
+      test.error(_("associativity must be > 0 and <= size_buffer.\n"));
     if (_associativity == 1) // special case : full assoc and direct map ... also we print direct map
       test.information("Branch Target Buffer is Direct Map");
+      test.information(_("Branch Target Buffer is Direct Map.\n"));
     else
       if (_associativity == _size_buffer)
         test.information("Branch Target Buffer is Full associative");
+        test.information(_("Branch Target Buffer is Full associative.\n"));
       else
         test.information("Branch Target Buffer is Semi associative");
+        test.information(_("Branch Target Buffer is Semi associative.\n"));
     for (uint32_t i=0; i<_nb_context; i++)
       if (_associativity < (_nb_instruction[i]/2))
         test.error("associativity must be >= nb_instruction["+toString(i)+"]/2.");
+        test.error(toString(_("associativity must be >= nb_instruction[%d]/2.\n"),i));
     log_printf(FUNC,Branch_Target_Buffer_Register,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/src/Parameters_print.cpp

r81	r88
31	31	xml.singleton_begin("size_buffer "); xml.attribut("value",toString(_size_buffer )); xml.singleton_end();
32	32	xml.singleton_begin("associativity "); xml.attribut("value",toString(_associativity )); xml.singleton_end();
33		xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
	33	// xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
34	34	xml.singleton_begin("size_counter "); xml.attribut("value",toString(_size_counter )); xml.singleton_end();
35	35	xml.singleton_begin("nb_inst_predict"); xml.attribut("value",toString(_nb_inst_predict)); xml.singleton_end();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/Makefile

r81	r88
24	24	library_clean : Branch_Target_Buffer_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/config_min.cfg

r82	r88
4	4	1 1 *4 # size_buffer
5	5	1 1 *4 # associativity
6		3~~2 32~~ *2 # size_address
	6	30 30 *2 # size_address
7	7	2 2 +1 # size_counter
8	8	1 1 *4 # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/config_mono_context.cfg

r81	r88
4	4	16 16 *4 # size_buffer
5	5	2 16 *4 # associativity
6		3~~2 32~~ *2 # size_address
	6	30 30 *2 # size_address
7	7	2 2 +1 # size_counter
8	8	1 4 *4 # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/config_multi_context.cfg

r81	r88
7	7	8 64 *4 # size_buffer
8	8	4 8 *2 # associativity
9		3~~2 32~~ *2 # size_address
	9	30 30 *2 # size_address
10	10	2 2 +1 # size_counter
11	11	1 4 *4 # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_inst_decod  ,
          _nb_inst_commit ,
+         _victim_scheme  );
+         _victim_scheme  ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/src/test.cpp

-              r82
+              r88
  */
 #define NB_ITERATION  1024
 #define CYCLE_MAX     (128*NB_ITERATION)
+#define NB_ITERATION  1
+#define CYCLE_MAX     (10000*NB_ITERATION)
 #include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/SelfTest/include/test.h"
 #include "Common/include/Test.h"
 #include "Behavioural/include/Allocation.h"
+#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register/SelfTest/include/test_BTB.h"
 void test (string name,
 …
 #ifdef STATISTICS
   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
+  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,CYCLE_MAX);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Branch_Target_Buffer * _Branch_Target_Buffer = new Branch_Target_Buffer
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
   /*********************************************************************
 …
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
+  // Initialisation
+  const uint32_t seed = 0;
+//const uint32_t seed = static_cast<uint32_t>(time(NULL));
+  srand(seed);
+  const  int32_t percent_transaction_decod   = 75;
+  const  int32_t percent_transaction_predict = 75;
+  SC_START(0);
   Time * _time = new Time();
 …
    ********************************************************/
+  // Initialisation
+  const uint32_t seed = 0;
+//const uint32_t seed = static_cast<uint32_t>(time(NULL));
+  srand(seed);
+  SC_START(0);
+  LABEL("Initialisation");
+  LABEL("Reset");
+  in_NRESET->write(0);
+  SC_START(5);
+  in_NRESET->write(1);
+  LABEL("Loop of Test");
+  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
+    {
+      LABEL("Iteration %d",iteration);
+      SC_START(1);
+    }
+  {
+    LABEL("Reset");
+    in_NRESET->write(0);
+    SC_START(5);
+    in_NRESET->write(1);
+    LABEL("Loop of Test");
+    Taddress_t btb_address [_param->_associativity];
+    Tcontext_t btb_context [_param->_associativity];
+    for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
+      {
+        LABEL("Iteration %d",iteration);
+        // FIRST STEP - Test (without sort, with concurent access, same context)
+        // fill a btb line
+#define NB_REQUEST (8*_param->_associativity)
+        uint32_t   nb_request;
+        uint32_t   index      = rand()&_param->_param_branch_target_buffer_register->_mask_bank;
+        Tcontext_t context    = rand()&_param->_nb_context;
+        for (uint32_t j=0; j<_param->_associativity; j++)
+//        btb_val     [j] = false;
+          btb_address [j] = static_cast<Taddress_t>(-1);
+        {
+          uint32_t associativity = 0;
+          while (associativity < _param->_associativity)
+            {
+              for (uint32_t j=0; j<_param->_nb_inst_decod; j++)
+                {
+                  Taddress_t address = ((associativity << _param->_param_branch_target_buffer_register->_shift_tag) |
+                                        (index         << _param->_param_branch_target_buffer_register->_shift_bank)|
+                                        (0));
+                  in_DECOD_VAL             [j]->write(((rand()%100)<percent_transaction_decod) and ((associativity+j) < _param->_associativity));
+                  in_DECOD_CONTEXT_ID      [j]->write(context);
+                  in_DECOD_ADDRESS_SRC     [j]->write( address );
+                  in_DECOD_ADDRESS_DEST    [j]->write(~address );
+                  in_DECOD_CONDITION       [j]->write(BRANCH_CONDITION_FLAG_SET);
+                  in_DECOD_LAST_TAKE       [j]->write(address&1);
+                  in_DECOD_MISS_PREDICTION [j]->write(1);
+                  in_DECOD_IS_ACCURATE     [j]->write(1);
+                }
+              SC_START(0);
+              for (uint32_t j=0; j<_param->_nb_inst_decod; j++)
+                if (in_DECOD_VAL [j]->read() and out_DECOD_ACK [j]->read())
+                  {
+                    LABEL("DECOD     [%d] Transaction Accepted",j);
+                    Taddress_t address = in_DECOD_ADDRESS_SRC [j]->read();
+                    btb_address[associativity] = address;
+                    btb_context[associativity] = context;
+                    associativity ++;
+                  }
+              SC_START(1);
+            }
+        }
+        nb_request = 0;
+        while (nb_request < NB_REQUEST)
+          {
+            for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+              {
+                in_PREDICT_VAL        [i]->write(((rand()%100)<percent_transaction_predict));
+                in_PREDICT_CONTEXT_ID [i]->write(rand()&_param->_nb_context);
+                in_PREDICT_ADDRESS    [i]->write(gen_addr(_param->_param_branch_target_buffer_register,index));
+              }
+            SC_START(0);
+            for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+              if (in_PREDICT_VAL [i]->read() and out_PREDICT_ACK [i]->read())
+                {
+                  LABEL("PREDICT   [%d] Transaction Accepted",i);
+                  Tcontrol_t hit          = out_PREDICT_HIT          [i]->read();
+                  Taddress_t address      =  in_PREDICT_ADDRESS      [i]->read();
+                  Taddress_t address_src  = out_PREDICT_ADDRESS_SRC  [i]->read();
+                  Taddress_t address_dest = out_PREDICT_ADDRESS_DEST [i]->read();
+                  Taddress_t tag          = address >> _param->_param_branch_target_buffer_register->_shift_tag;
+                  Tcontrol_t my_hit = false;
+                  Tcontrol_t my_addr;
+                  for (uint32_t i=0; i<_param->_associativity; i++)
+                    {
+                      Taddress_t btb_address [_param->_associativity];
+                      Tcontext_t btb_context [_param->_associativity];
+                    }
+                  if (hit)
+                    {
+                      TEST(Tbranch_condition_t,out_PREDICT_CONDITION   [i]->read(),BRANCH_CONDITION_FLAG_SET);
+                      TEST(Tcontrol_t         ,out_PREDICT_LAST_TAKE   [i]->read(),address_src&1);
+//                    TEST(Tcontrol_t         ,out_PREDICT_IS_ACCURATE [i]->read(), );
+                    }
+                  nb_request ++;
+                }
+            SC_START(1);
+          }
+      }
+  }
   /********************************************************

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/include/Parameters.h

-              r81
+              r88
   public : uint32_t   _size_buffer    ;
   public : uint32_t   _associativity  ;
   public : uint32_t   _size_address   ;
+//public : uint32_t   _size_address   ;
   public : uint32_t   _size_counter   ;
   public : uint32_t   _nb_inst_predict;
 …
   public : uint32_t   _size_bank      ;
   public : uint32_t   _size_context_id;
+//public : uint32_t   _size_context_id;
   public : uint32_t   _size_victim    ;
   public : bool       _have_port_context_id;
+//public : bool       _have_port_context_id;
   public : bool       _have_component_victim;
   public : bool       _is_full_associative;
 …
                         uint32_t   nb_inst_decod  ,
                         uint32_t   nb_inst_update ,
+                        Tvictim_t  victim_scheme  );
+                        Tvictim_t  victim_scheme  ,
+                        bool       is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Branch_Target_Buffer.cpp

-              r81
+              r88
     log_printf(INFO,Branch_Target_Buffer,FUNCTION,"Allocation");
+#if DEBUG_Branch_Target_Buffer == true
+    log_printf(INFO,Branch_Target_Buffer,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     allocation (
 #ifdef STATISTICS
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Branch_Target_Buffer,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Branch_Target_Buffer,FUNCTION,"Method - transition");
+        log_printf(INFO,Branch_Target_Buffer,FUNCTION,_("Method - transition"));
         SC_METHOD (transition);
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Branch_Target_Buffer_allocation.cpp

-              r82
+              r88
       ALLOC1_VALACK_OUT(out_PREDICT_ACK         ,ACK);
       ALLOC1_SIGNAL_IN ( in_PREDICT_CONTEXT_ID  ,"context_id"  ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS     ,"address"     ,Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS     ,"address"     ,Tgeneral_data_t    ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_PREDICT_HIT         ,"hit"         ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC ,"address_src" ,Tgeneral_data_t    ,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST,"address_dest",Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC ,"address_src" ,Tgeneral_data_t    ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST,"address_dest",Tgeneral_data_t    ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_PREDICT_CONDITION   ,"condition"   ,Tbranch_condition_t,_param->_size_branch_condition);
       ALLOC1_SIGNAL_OUT(out_PREDICT_LAST_TAKE   ,"last_take"   ,Tcontrol_t         ,1);
 …
       ALLOC1_VALACK_OUT(out_DECOD_ACK            ,ACK);
       ALLOC1_SIGNAL_IN ( in_DECOD_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_condition);
       ALLOC1_SIGNAL_IN ( in_DECOD_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
 …
       ALLOC1_VALACK_OUT(out_UPDATE_ACK            ,ACK);
       ALLOC1_SIGNAL_IN ( in_UPDATE_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_SRC    ,"address_src"    ,Tgeneral_data_t    ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS_DEST   ,"address_dest"   ,Tgeneral_data_t    ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_condition);
       ALLOC1_SIGNAL_IN ( in_UPDATE_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
 …
+    }
     // ~~~~~[ Others ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//      _component->test_map();
+#ifdef POSITION
+    _component->generate_file();
+#if DEBUG_Branch_Target_Buffer == true
+    _component->test_map();
+#endif
+#ifdef POSITION
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Branch_Target_Buffer_deallocation.cpp

r82	r88
23	23	log_printf(FUNC,Branch_Target_Buffer,FUNCTION,"Begin");
24	24
25		if (~~_usage & USE_SYSTEMC~~)
	25	if (usage_is_set(_usage,USE_SYSTEMC))
26	26	{
27	27	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Branch_Target_Buffer_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Branch_Target_Buffer_statistics_allocation.cpp

-              r81
+              r88
         _stat->add_stat(_component_victim ->_stat);
+      }
+    _stat->add_stat(_component_branch_target_buffer_glue    ->_stat);
+//     _stat->add_stat(_component_branch_target_buffer_glue    ->_stat);
     _stat->add_stat(_component_branch_target_buffer_register->_stat);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Branch_Target_Buffer_statistics_deallocation.cpp

r81	r88
	1
1	2	#ifdef STATISTICS
2	3	/*

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_inst_decod  ,
                           uint32_t   nb_inst_update ,
+                          Tvictim_t  victim_scheme  )
+                          Tvictim_t  victim_scheme  ,
+                          bool       is_toplevel)
+  {
     log_printf(FUNC,Branch_Target_Buffer,FUNCTION,"Begin");
 …
     _size_buffer     = size_buffer    ;
     _associativity   = associativity  ;
-    _size_address    = size_address   ;
     _size_counter    = size_counter   ;
     _nb_inst_predict = nb_inst_predict;
 …
     _size_bank       = size_buffer/associativity;
-    _size_context_id = log2(nb_context);
     _size_victim     = log2(associativity);
-    _have_port_context_id   = (_size_context_id > 0);
     _have_component_victim  = (_size_victim     > 0);
     _is_full_associative    = _size_bank == 1;
     uint32_t nb_access = nb_inst_predict + nb_inst_decod + nb_inst_update;
+    test();
     if (_have_component_victim)
 …
        _size_buffer       ,
        _associativity     ,
        _size_address      ,
+        size_address      ,
        _nb_inst_predict   ,
        _nb_inst_decod     ,
        _nb_inst_update    );
     _param_branch_target_buffer_register = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::branch_target_buffer::branch_target_buffer_register::Parameters
       (_nb_context     ,
 …
        _size_buffer    ,
        _associativity  ,
        _size_address   ,
+        size_address   ,
        _size_counter   ,
        _nb_inst_predict,
 …
        _nb_inst_update );
+    test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address   ;
+        _size_context_id          = log2(nb_context);
+        _have_port_context_id     = (_size_context_id > 0);
+        copy ();
+      }
     log_printf(FUNC,Branch_Target_Buffer,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Branch_Target_Buffer::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Branch_Target_Buffer,FUNCTION,"Begin");
+    if (_have_component_victim)
+      {
+        COPY(_param_sort);
+        COPY(_param_victim);
+      }
+    COPY(_param_branch_target_buffer_glue);
+    COPY(_param_branch_target_buffer_register);
+    log_printf(FUNC,Branch_Target_Buffer,FUNCTION,"End");
+  };
 }; // end namespace branch_target_buffer
 }; // end namespace prediction_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/src/Parameters_print.cpp

r81	r88
30	30	xml.singleton_begin("size_buffer "); xml.attribut("value",toString(_size_buffer )); xml.singleton_end();
31	31	xml.singleton_begin("associativity "); xml.attribut("value",toString(_associativity )); xml.singleton_end();
32		xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
	32	// xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
33	33	xml.singleton_begin("size_counter "); xml.attribut("value",toString(_size_counter )); xml.singleton_end();
34	34	xml.singleton_begin("nb_inst_predict"); xml.attribut("value",toString(_nb_inst_predict)); xml.singleton_end();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/SelfTest/Makefile

r81	r88
24	24	library_clean : Direction_Glue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_inst_update  ,
          _size_address    ,
+         _size_history    );
+         _size_history    ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Direction_Glue * _Direction_Glue = new Direction_Glue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
+        {
           in_PREDICT_VAL                 [i]->write(rand()%2);
           in_PREDICT_ADDRESS_SRC         [i]->write(range<Taddress_t>(rand(),_param->_size_address));
+          in_PREDICT_ADDRESS_SRC         [i]->write(range<Taddress_t>(rand(),_param->_size_instruction_address));
           in_PREDICT_STATIC              [i]->write(rand()%2);
           in_PREDICT_LAST_TAKE           [i]->write(rand()%2);
 …
+        {
           in_UPDATE_VAL                  [i]->write(rand()%2);
           in_UPDATE_ADDRESS              [i]->write(range<Taddress_t>(rand(),_param->_size_address));
+          in_UPDATE_ADDRESS              [i]->write(range<Taddress_t>(rand(),_param->_size_instruction_address));
           in_UPDATE_HISTORY              [i]->write(range<Thistory_t>(rand(),_param->_size_history));
           in_UPDATE_DIRECTION            [i]->write(rand()%2);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/include/Parameters.h

-              r81
+              r88
   public : uint32_t     _nb_inst_predict ;
   public : uint32_t     _nb_inst_update  ;
   public : uint32_t     _size_address    ;
+//public : uint32_t     _size_address    ;
   public : uint32_t     _size_history    ;
 …
                         uint32_t     nb_inst_update  ,
                         uint32_t     size_address    ,
+                        uint32_t     size_history    );
+                        uint32_t     size_history    ,
+                        bool         is_toplevel=false
+                        );
     //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/src/Direction_Glue.cpp

-              r81
+              r88
     log_printf(FUNC,Direction_Glue,FUNCTION,"Begin");
+#if DEBUG_Direction_Glue == true
+    log_printf(INFO,Direction_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Direction_Glue,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Direction_Glue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         bool need_genmealy_predict = true;
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/src/Direction_Glue_allocation.cpp

-              r81
+              r88
       ALLOC1_SIGNAL_IN ( in_PREDICT_VAL                  ,"val"                  ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_PREDICT_ACK                  ,"ack"                  ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS_SRC          ,"address_src"          ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS_SRC          ,"address_src"          ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_PREDICT_STATIC               ,"static"               ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_LAST_TAKE            ,"last_take"            ,Tcontrol_t,1);
 …
       ALLOC1_SIGNAL_OUT(out_PREDICT_PREDICTOR_VAL        ,"predictor_val"        ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_PREDICTOR_ACK        ,"predictor_ack"        ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_PREDICT_PREDICTOR_ADDRESS_SRC,"predictor_address_src",Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_PREDICT_PREDICTOR_ADDRESS_SRC,"predictor_address_src",Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_PREDICT_PREDICTOR_HISTORY    ,"predictor_history"    ,Thistory_t,_param->_size_history);
       ALLOC1_SIGNAL_IN ( in_PREDICT_PREDICTOR_DIRECTION  ,"predictor_direction"  ,Tcontrol_t,1);
 …
       ALLOC1_SIGNAL_IN ( in_UPDATE_VAL                ,"val"                ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_UPDATE_ACK                ,"ack"                ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS            ,"address"            ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS            ,"address"            ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_HISTORY            ,"history"            ,Thistory_t,_param->_size_history);
       ALLOC1_SIGNAL_IN ( in_UPDATE_DIRECTION          ,"direction"          ,Tcontrol_t,1);
 …
       ALLOC1_SIGNAL_OUT(out_UPDATE_PREDICTOR_VAL      ,"predictor_val"      ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_UPDATE_PREDICTOR_ACK      ,"predictor_ack"      ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_UPDATE_PREDICTOR_ADDRESS  ,"predictor_address"  ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_PREDICTOR_ADDRESS  ,"predictor_address"  ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_UPDATE_PREDICTOR_HISTORY  ,"predictor_history"  ,Thistory_t,_param->_size_history);
       ALLOC1_SIGNAL_OUT(out_UPDATE_PREDICTOR_DIRECTION,"predictor_direction",Tcontrol_t,1);
+        }
+    }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/src/Direction_Glue_deallocation.cpp

r81	r88
24	24	log_printf(FUNC,Direction_Glue,FUNCTION,"Begin");
25	25
26		if (~~_usage & USE_SYSTEMC~~)
	26	if (usage_is_set(_usage,USE_SYSTEMC))
27	27	{
28	28	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/src/Direction_Glue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/src/Parameters.cpp

-              r81
+              r88
                           uint32_t     nb_inst_update  ,
                           uint32_t     size_address    ,
+                          uint32_t     size_history    )
+                          uint32_t     size_history    ,
+                          bool         is_toplevel     )
+  {
     log_printf(FUNC,Direction_Glue,FUNCTION,"Begin");
 …
     _nb_inst_predict  = nb_inst_predict ;
     _nb_inst_update   = nb_inst_update  ;
-    _size_address     = size_address    ;
     switch (predictor_scheme)
 …
     test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address;
+        copy();
+      }
     log_printf(FUNC,Direction_Glue,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Direction_Glue::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Direction_Glue,FUNCTION,"Begin");
+    log_printf(FUNC,Direction_Glue,FUNCTION,"End");
+  };
 }; // end namespace direction_glue
 }; // end namespace direction

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue/src/Parameters_print.cpp

r81	r88
31	31	xml.singleton_begin("nb_inst_predict "); xml.attribut("value",toString(_nb_inst_predict )); xml.singleton_end();
32	32	xml.singleton_begin("nb_inst_update "); xml.attribut("value",toString(_nb_inst_update )); xml.singleton_end();
33		xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
	33	// xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
34	34	xml.singleton_begin("size_history "); xml.attribut("value",toString(_size_history )); xml.singleton_end();
35	35	xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/SelfTest/Makefile

r81	r88
24	24	library_clean : Direction_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/SelfTest/src/main.cpp

-              r81
+              r88
          _pht_size_counter      ,
          _pht_nb_counter        ,
+         _pht_size_address_share);
+         _pht_size_address_share,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Direction * _Direction = new Direction
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
+        {
           in_PREDICT_VAL                 [i]->write(rand()%2);
           in_PREDICT_ADDRESS_SRC         [i]->write(range<Taddress_t>(rand(),_param->_size_address));
+          in_PREDICT_ADDRESS_SRC         [i]->write(range<Taddress_t>(rand(),_param->_size_instruction_address));
           in_PREDICT_STATIC              [i]->write(rand()%2);
           in_PREDICT_LAST_TAKE           [i]->write(rand()%2);
 …
+        {
           in_UPDATE_VAL                  [i]->write(rand()%2);
           in_UPDATE_ADDRESS              [i]->write(range<Taddress_t>(rand(),_param->_size_address));
+          in_UPDATE_ADDRESS              [i]->write(range<Taddress_t>(rand(),_param->_size_instruction_address));
           in_UPDATE_HISTORY              [i]->write(range<Thistory_t>(rand(),_param->_size_history));
           in_UPDATE_DIRECTION            [i]->write(rand()%2);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/include/Parameters.h

-              r81
+              r88
   public : uint32_t     _nb_inst_predict           ;
   public : uint32_t     _nb_inst_update            ;
   public : uint32_t     _size_address              ;
+//public : uint32_t     _size_address              ;
   public : bool         _have_bht               [3];
   public : uint32_t     _bht_size_shifter       [3];
 …
                         uint32_t     pht_size_counter       [3],
                         uint32_t     pht_nb_counter         [3],
+                        uint32_t     pht_size_address_share [3]);
+                        uint32_t     pht_size_address_share [3],
+                        bool         is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/src/Direction.cpp

-              r81
+              r88
     log_printf(FUNC,Direction,FUNCTION,"Begin");
+#if DEBUG_Direction == true
+    log_printf(INFO,Direction,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Direction,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Direction,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Direction,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/src/Direction_allocation.cpp

-              r82
+              r88
       ALLOC1_VALACK_IN ( in_PREDICT_VAL        ,VAL);
       ALLOC1_VALACK_OUT(out_PREDICT_ACK        ,ACK);
       ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS_SRC,"address_src",Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS_SRC,"address_src",Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_PREDICT_STATIC     ,"static"     ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_LAST_TAKE  ,"last_take"  ,Tcontrol_t,1);
 …
       ALLOC1_VALACK_IN ( in_UPDATE_VAL      ,VAL);
       ALLOC1_VALACK_OUT(out_UPDATE_ACK      ,ACK);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS  ,"address"  ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS  ,"address"  ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_HISTORY  ,"history"  ,Thistory_t,_param->_size_history);
       ALLOC1_SIGNAL_IN ( in_UPDATE_DIRECTION,"direction",Tcontrol_t,1);
 …
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/src/Direction_deallocation.cpp

r81	r88
23	23	log_printf(FUNC,Direction,FUNCTION,"Begin");
24	24
25		if (~~_usage & USE_SYSTEMC~~)
	25	if (usage_is_set(_usage,USE_SYSTEMC))
26	26	{
27	27	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/src/Direction_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/src/Parameters.cpp

-              r81
+              r88
                           uint32_t     pht_size_counter       [3],
                           uint32_t     pht_nb_counter         [3],
+                          uint32_t     pht_size_address_share [3])
+                          uint32_t     pht_size_address_share [3],
+                          bool         is_toplevel)
+  {
     log_printf(FUNC,Direction,FUNCTION,"Begin");
 …
     _nb_inst_predict        = nb_inst_predict       ;
     _nb_inst_update         = nb_inst_update        ;
     _size_address           = size_address          ;
+//  _size_address           = size_address          ;
     for (uint32_t i=0; i<3; i++)
 …
     _have_port_history = (_size_history > 0);
+    test();
     _param_glue = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::direction::direction_glue::Parameters
       (_predictor_scheme,
        _nb_inst_predict ,
        _nb_inst_update  ,
        _size_address    ,
+        size_address    ,
        _size_history    );
+    test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address;
+        copy ();
+      }
     log_printf(FUNC,Direction,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Direction::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Direction,FUNCTION,"Begin");
+    COPY(_param_glue);
+    log_printf(FUNC,Direction,FUNCTION,"End");
+  };
 }; // end namespace direction
 }; // end namespace prediction_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/src/Parameters_print.cpp

r81	r88
30	30	xml.singleton_begin("nb_inst_predict "); xml.attribut("value",toString(_nb_inst_predict )); xml.singleton_end();
31	31	xml.singleton_begin("nb_inst_update "); xml.attribut("value",toString(_nb_inst_update )); xml.singleton_end();
32		xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
	32	// xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
33	33
34	34	xml.comment("predictor_scheme : ");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/Makefile

r81	r88
24	24	library_clean : Prediction_unit_Glue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/src/main.cpp

-              r82
+              r88
          _nb_inst_branch_predict,
          _nb_inst_branch_decod  ,
+         _nb_inst_branch_update );
+         _nb_inst_branch_update ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/SelfTest/src/test.cpp

-              r82
+              r88
   ALLOC1_SC_SIGNAL(out_PREDICT_PC_NEXT                     ,"out_PREDICT_PC_NEXT                    ",Taddress_t         ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_PREDICT_PC_NEXT_IS_DS_TAKE          ,"out_PREDICT_PC_NEXT_IS_DS_TAKE         ",Tcontrol_t         ,_param->_nb_context);
   ALLOC2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE          ,"out_PREDICT_INSTRUCTION_ENABLE         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE          ,"out_PREDICT_INSTRUCTION_ENABLE         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_instruction[it1]);
   ALLOC1_SC_SIGNAL(out_PREDICT_INST_IFETCH_PTR             ,"out_PREDICT_INST_IFETCH_PTR            ",Tinst_ifetch_ptr_t ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_PREDICT_BRANCH_STATE                ,"out_PREDICT_BRANCH_STATE               ",Tbranch_state_t    ,_param->_nb_context);
 …
   ALLOC1_SC_SIGNAL( in_PREDICT_UPT_ACK                     ," in_PREDICT_UPT_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_predict);
   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_CONTEXT_ID              ,"out_PREDICT_UPT_CONTEXT_ID             ",Tcontext_t         ,_param->_nb_inst_branch_predict);
+  ALLOC1_SC_SIGNAL( in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID ,"out_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID",Tprediction_ptr_t  ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC         ,"out_PREDICT_UPT_BTB_ADDRESS_SRC        ",Taddress_t         ,_param->_nb_inst_branch_predict);
   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST        ,"out_PREDICT_UPT_BTB_ADDRESS_DEST       ",Taddress_t         ,_param->_nb_inst_branch_predict);
 …
   ALLOC1_SC_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS             ,"out_PREDICT_UPT_RAS_ADDRESS            ",Taddress_t         ,_param->_nb_inst_branch_predict);
 //ALLOC1_SC_SIGNAL(out_PREDICT_UPT_RAS_INDEX               ,"out_PREDICT_UPT_RAS_INDEX              ",Tptr_t             ,_param->_nb_inst_branch_predict);
   ALLOC1_SC_SIGNAL( in_DEPTH_UPT_NB_BRANCH                 ," in_DEPTH_UPT_NB_BRANCH                ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL( in_DEPTH_UPT_TAIL                      ," in_DEPTH_UPT_TAIL                     ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_DEPTH_NB_BRANCH                     ,"out_DEPTH_NB_BRANCH                    ",Tdepth_t           ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_DEPTH_TAIL                          ,"out_DEPTH_TAIL                         ",Tdepth_t           ,_param->_nb_context);
   ALLOC2_SC_SIGNAL( in_DECOD_VAL                        ," in_DECOD_VAL                        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL(out_DECOD_ACK                        ,"out_DECOD_ACK                        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ," in_DECOD_CONTEXT_ID                 ",Tcontext_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ," in_DECOD_MATCH_INST_IFETCH_PTR      ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ," in_DECOD_BRANCH_STATE               ",Tbranch_state_t    ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID," in_DECOD_BRANCH_UPDATE_PREDICTION_ID",Tprediction_ptr_t  ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ," in_DECOD_BRANCH_CONDITION           ",Tbranch_condition_t,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ," in_DECOD_BRANCH_DIRECTION           ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ," in_DECOD_ADDRESS_SRC                ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ," in_DECOD_ADDRESS_DEST               ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+//   ALLOC1_SC_SIGNAL( in_DEPTH_UPT_NB_BRANCH                 ," in_DEPTH_UPT_NB_BRANCH                ",Tdepth_t           ,_param->_nb_context);
+//   ALLOC1_SC_SIGNAL( in_DEPTH_UPT_TAIL                      ," in_DEPTH_UPT_TAIL                     ",Tdepth_t           ,_param->_nb_context);
+//   ALLOC1_SC_SIGNAL(out_DEPTH_NB_BRANCH                     ,"out_DEPTH_NB_BRANCH                    ",Tdepth_t           ,_param->_nb_context);
+//   ALLOC1_SC_SIGNAL(out_DEPTH_TAIL                          ,"out_DEPTH_TAIL                         ",Tdepth_t           ,_param->_nb_context);
+  ALLOC2_SC_SIGNAL( in_DECOD_VAL                        ," in_DECOD_VAL                        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL(out_DECOD_ACK                        ,"out_DECOD_ACK                        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ," in_DECOD_CONTEXT_ID                 ",Tcontext_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ," in_DECOD_MATCH_INST_IFETCH_PTR      ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ," in_DECOD_BRANCH_STATE               ",Tbranch_state_t    ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID," in_DECOD_BRANCH_UPDATE_PREDICTION_ID",Tprediction_ptr_t  ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ," in_DECOD_BRANCH_CONDITION           ",Tbranch_condition_t,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ," in_DECOD_BRANCH_DIRECTION           ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ," in_DECOD_ADDRESS_SRC                ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ," in_DECOD_ADDRESS_DEST               ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   ALLOC1_SC_SIGNAL(out_DECOD_BTB_VAL                    ,"out_DECOD_BTB_VAL                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
   ALLOC1_SC_SIGNAL( in_DECOD_BTB_ACK                    ," in_DECOD_BTB_ACK                    ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
 …
   ALLOC1_SC_SIGNAL(out_DECOD_UPT_MISS_DECOD             ,"out_DECOD_UPT_MISS_DECOD             ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID   ,"out_DECOD_UPT_UPDATE_PREDICTION_ID   ",Tprediction_ptr_t  ,_param->_nb_inst_branch_decod);
+  ALLOC1_SC_SIGNAL(out_DECOD_UPT_IS_ACCURATE            ,"out_DECOD_UPT_IS_ACCURATE            ",Tcontrol_t         ,_param->_nb_inst_branch_decod);
   ALLOC1_SC_SIGNAL(out_UPDATE_BTB_VAL                  ,"out_UPDATE_BTB_VAL                  ",Tcontrol_t         ,_param->_nb_inst_branch_update);
 …
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_PC_NEXT                     ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_PC_NEXT_IS_DS_TAKE          ,_param->_nb_context);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_INSTRUCTION_ENABLE          ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_INSTRUCTION_ENABLE          ,_param->_nb_context,_param->_nb_instruction[it1]);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BRANCH_STATE                ,_param->_nb_context);
   for (uint32_t i=0; i<_param->_nb_context; i++)
+    {
       if (_param->_have_port_inst_ifetch_ptr [i])
         INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_INST_IFETCH_PTR [i]);
       if (_param->_have_port_depth [i])
+      if (_param->_have_port_inst_ifetch_ptr)
+        INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_INST_IFETCH_PTR [i]);
+      if (_param->_have_port_depth)
         INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i]);
+    }
 …
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
+  if (_param->_have_port_depth)
+  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_branch_predict);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_ADDRESS_SRC         ,_param->_nb_inst_branch_predict);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_BTB_ADDRESS_DEST        ,_param->_nb_inst_branch_predict);
 …
 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_PREDICT_UPT_RAS_INDEX               ,_param->_nb_inst_branch_predict);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   if (_param->_have_port_context_id)
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   if (_param->_have_port_max_depth)
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  if (_param->_have_port_depth)
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_BTB_VAL                    ,_param->_nb_inst_branch_decod);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_DECOD_BTB_ACK                    ,_param->_nb_inst_branch_decod);
 …
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_MISS_IFETCH            ,_param->_nb_inst_branch_decod);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_MISS_DECOD             ,_param->_nb_inst_branch_decod);
   if (_param->_have_port_max_depth)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_branch_decod);
+  INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_DECOD_UPT_IS_ACCURATE            ,_param->_nb_inst_branch_decod);
   INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue,out_UPDATE_BTB_VAL                  ,_param->_nb_inst_branch_update);
 …
 //INSTANCE1_SC_SIGNAL(_Prediction_unit_Glue, in_UPDATE_UPT_RAS_PREDICTION_IFETCH,_param->_nb_inst_branch_update);
   for (uint32_t i=0; i<_param->_nb_context; i++)
+    {
       if (_param->_have_port_depth [i])
+        {
           INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_TAIL      [i]);
           INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_DEPTH_TAIL          [i]);
+        }
           INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_NB_BRANCH [i]);
           INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_DEPTH_NB_BRANCH     [i]);
+    }
+//   for (uint32_t i=0; i<_param->_nb_context; i++)
+//     {
+//       if (_param->_have_port_depth)
+//      {
+//        INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_TAIL      [i]);
+//        INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_DEPTH_TAIL          [i]);
+//      }
+//        INSTANCE_SC_SIGNAL(_Prediction_unit_Glue, in_DEPTH_UPT_NB_BRANCH [i]);
+//        INSTANCE_SC_SIGNAL(_Prediction_unit_Glue,out_DEPTH_NB_BRANCH     [i]);
+//     }
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
+              {
                 in_DECOD_VAL                         [decod_unit][i]->write((rand()%100)<percent_transaction_decod);
                 in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]->write(rand()%_param->_size_depth[context]);
+                in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]->write(rand()%_param->_array_size_depth[context]);
                 in_DECOD_BTB_ACK[0]->write((rand()%100)<percent_transaction_decod);
 …
             in_DECOD_MATCH_INST_IFETCH_PTR       [decod_unit][i]->write(0);
             in_DECOD_BRANCH_STATE                [decod_unit][i]->write(BRANCH_STATE_SPEC_TAKE);
             in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]->write(i%_param->_max_size_depth);
+            in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]->write(i%_param->_size_depth);
             in_DECOD_BRANCH_CONDITION            [decod_unit][i]->write(BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK);
             in_DECOD_BRANCH_DIRECTION            [decod_unit][i]->write(1);
 …
                     TEST(Tcontext_t         ,out_DECOD_RAS_CONTEXT_ID           [0]->read(),context);
                     TEST(Tcontrol_t         ,out_DECOD_RAS_PUSH                 [0]->read(),1);
                     TEST(Taddress_t         ,out_DECOD_RAS_ADDRESS_PUSH         [0]->read(),0x11061979+i);
+                    TEST(Taddress_t         ,out_DECOD_RAS_ADDRESS_PUSH         [0]->read(),0xdeadbeef+i+2);
                     TEST(Tcontrol_t         ,out_DECOD_RAS_MISS_PREDICTION      [0]->read(),1);
                     TEST(Tcontext_t         ,out_DECOD_UPT_CONTEXT_ID           [0]->read(),context);
 …
                     TEST(Tcontrol_t         ,out_DECOD_UPT_MISS_IFETCH          [0]->read(),1);
                     TEST(Tcontrol_t         ,out_DECOD_UPT_MISS_DECOD           [0]->read(),0);
+                    TEST(Tprediction_ptr_t  ,out_DECOD_UPT_UPDATE_PREDICTION_ID [0]->read(),i%_param->_max_size_depth);
+                    TEST(Tprediction_ptr_t  ,out_DECOD_UPT_UPDATE_PREDICTION_ID [0]->read(),i%_param->_size_depth);
+                    TEST(Tcontrol_t         ,out_DECOD_UPT_IS_ACCURATE          [0]->read(),0);
                     find = true;
 …
   DELETE1_SC_SIGNAL(out_PREDICT_PC_NEXT                     ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_PREDICT_PC_NEXT_IS_DS_TAKE          ,_param->_nb_context);
   DELETE2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE          ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+  DELETE2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE          ,_param->_nb_context,_param->_nb_instruction[it1]);
   DELETE1_SC_SIGNAL(out_PREDICT_INST_IFETCH_PTR             ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_PREDICT_BRANCH_STATE                ,_param->_nb_context);
 …
   DELETE1_SC_SIGNAL(out_PREDICT_UPT_VAL                     ,_param->_nb_inst_branch_predict);
   DELETE1_SC_SIGNAL( in_PREDICT_UPT_ACK                     ,_param->_nb_inst_branch_predict);
+  DELETE1_SC_SIGNAL( in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_branch_predict);
   DELETE1_SC_SIGNAL(out_PREDICT_UPT_CONTEXT_ID              ,_param->_nb_inst_branch_predict);
   DELETE1_SC_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC         ,_param->_nb_inst_branch_predict);
 …
   DELETE1_SC_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS             ,_param->_nb_inst_branch_predict);
 //DELETE1_SC_SIGNAL(out_PREDICT_UPT_RAS_INDEX               ,_param->_nb_inst_branch_predict);
   DELETE1_SC_SIGNAL( in_DEPTH_UPT_NB_BRANCH                 ,_param->_nb_context);
   DELETE1_SC_SIGNAL( in_DEPTH_UPT_TAIL                      ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_DEPTH_NB_BRANCH                     ,_param->_nb_context);
   DELETE1_SC_SIGNAL(out_DEPTH_TAIL                          ,_param->_nb_context);
   DELETE2_SC_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+//   DELETE1_SC_SIGNAL( in_DEPTH_UPT_NB_BRANCH                 ,_param->_nb_context);
+//   DELETE1_SC_SIGNAL( in_DEPTH_UPT_TAIL                      ,_param->_nb_context);
+//   DELETE1_SC_SIGNAL(out_DEPTH_NB_BRANCH                     ,_param->_nb_context);
+//   DELETE1_SC_SIGNAL(out_DEPTH_TAIL                          ,_param->_nb_context);
+  DELETE2_SC_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   DELETE1_SC_SIGNAL(out_DECOD_BTB_VAL                    ,_param->_nb_inst_branch_decod);
   DELETE1_SC_SIGNAL( in_DECOD_BTB_ACK                    ,_param->_nb_inst_branch_decod);
 …
   DELETE1_SC_SIGNAL(out_DECOD_UPT_MISS_DECOD             ,_param->_nb_inst_branch_decod);
   DELETE1_SC_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_branch_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_UPT_IS_ACCURATE            ,_param->_nb_inst_branch_decod);
   DELETE1_SC_SIGNAL(out_UPDATE_BTB_VAL                  ,_param->_nb_inst_branch_update);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/include/Parameters.h

-              r82
+              r88
   public : uint32_t   _nb_decod_unit            ;
 //public : uint32_t   _nb_ooo_engine            ;
   public : uint32_t   _size_address             ;
+//public : uint32_t   _size_address             ;
   public : uint32_t * _nb_instruction           ;//[nb_context]
+  public : uint32_t * _size_depth               ;//[nb_context]
+//public : uint32_t * _size_depth               ;//[nb_context]
+  public : uint32_t * _array_size_depth         ;//[nb_context]
   public : uint32_t * _nb_inst_decod            ;//[nb_decod_unit]
 //public : uint32_t * _nb_inst_update           ;//[nb_ooo_engine]
 …
 //public : uint32_t   _nb_inst_branch_complete  ;
   public : uint32_t   _size_context_id          ;
   public : uint32_t * _size_inst_ifetch_ptr     ;//[nb_context]
   public : uint32_t   _max_size_depth           ;
+//public : uint32_t   _size_context_id          ;
+//public : uint32_t * _size_inst_ifetch_ptr     ;//[nb_context]
+//public : uint32_t   _max_size_depth           ;
   public : bool       _have_port_context_id     ;
   public : bool       _have_port_max_depth      ;
   public : bool     * _have_port_depth          ;//[nb_context]
   public : bool     * _have_port_inst_ifetch_ptr;//[nb_context]
+//public : bool       _have_port_context_id     ;
+//public : bool       _have_port_max_depth      ;
+//public : bool     * _have_port_depth          ;//[nb_context]
+//public : bool     * _have_port_inst_ifetch_ptr;//[nb_context]
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t   nb_decod_unit         ,
 //                      uint32_t   nb_ooo_engine         ,
                         uint32_t   size_address          ,
+                        uint32_t   size_address          ,
                         uint32_t * nb_instruction        ,
                         uint32_t * size_depth            ,
 …
                         uint32_t   nb_inst_branch_predict,
                         uint32_t   nb_inst_branch_decod  ,
+                        uint32_t   nb_inst_branch_update );
+                        uint32_t   nb_inst_branch_update ,
+                        bool       is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/include/Prediction_unit_Glue.h

-              r82
+              r88
   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_UPT_ACK                     ; //[nb_inst_branch_predict]
   public    : SC_OUT(Tcontext_t         )  ** out_PREDICT_UPT_CONTEXT_ID              ; //[nb_inst_branch_predict]
+  public    : SC_IN (Tprediction_ptr_t  )  **  in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID; //[nb_inst_branch_predict]
   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_BTB_ADDRESS_SRC         ; //[nb_inst_branch_predict]* BTB.ADDRESS_SRC
   public    : SC_OUT(Taddress_t         )  ** out_PREDICT_UPT_BTB_ADDRESS_DEST        ; //[nb_inst_branch_predict]
 …
   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_MISS_DECOD                ; //[nb_inst_branch_decod]
   public    : SC_OUT(Tprediction_ptr_t  )  ** out_DECOD_UPT_UPDATE_PREDICTION_ID      ; //[nb_inst_branch_decod]
+  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_UPT_IS_ACCURATE               ; //[nb_inst_branch_decod]
     // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
 //public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_UPT_RAS_PREDICTION_IFETCH    ; //[nb_inst_branch_update] RAS.PREDICTION_IFETCH
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tdepth_t           )  **  in_DEPTH_UPT_NB_BRANCH                 ; //[nb_context]
   public    : SC_IN (Tdepth_t           )  **  in_DEPTH_UPT_TAIL                      ; //[nb_context]
   public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_NB_BRANCH                     ; //[nb_context]
   public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_TAIL                          ; //[nb_context]
+//  // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//public    : SC_IN (Tdepth_t           )  **  in_DEPTH_UPT_NB_BRANCH                 ; //[nb_context]
+//public    : SC_IN (Tdepth_t           )  **  in_DEPTH_UPT_TAIL                      ; //[nb_context]
+//public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_NB_BRANCH                     ; //[nb_context]
+//public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_TAIL                          ; //[nb_context]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Parameters.cpp

-              r82
+              r88
                           uint32_t   nb_inst_branch_predict,
                           uint32_t   nb_inst_branch_decod  ,
+                          uint32_t   nb_inst_branch_update )
+                          uint32_t   nb_inst_branch_update ,
+                          bool       is_toplevel
+                          )
+  {
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
     _nb_context                = nb_context     ;
-    _size_address              = size_address   ;
     _nb_instruction            = nb_instruction ;
+    _size_depth                = size_depth     ;
+//  _size_depth                = size_depth     ;
+    _array_size_depth          = size_depth     ;
     _nb_decod_unit             = nb_decod_unit  ;
     _nb_inst_decod             = nb_inst_decod  ;
 //     _nb_ooo_engine             = nb_ooo_engine  ;
 //     _nb_inst_update            = nb_inst_update ;
+//  _nb_ooo_engine             = nb_ooo_engine  ;
+//  _nb_inst_update            = nb_inst_update ;
     _nb_inst_branch_predict    = nb_inst_branch_predict;
     _nb_inst_branch_decod      = nb_inst_branch_decod  ;
     _nb_inst_branch_update     = nb_inst_branch_update ;
+    _size_context_id           = log2(_nb_context);
+    _size_inst_ifetch_ptr      = new uint32_t [_nb_context];
+    _max_size_depth            = max<uint32_t>(_size_depth,_nb_context);
+    test();
+    _have_port_context_id      = (_size_context_id>0);
+    _have_port_max_depth       = (_max_size_depth>0);
+    _have_port_depth           = new bool [_nb_context];
+    _have_port_inst_ifetch_ptr = new bool [_nb_context];
+    if (is_toplevel)
+      {
+        _size_instruction_address  = size_address;
+        _size_context_id           = log2(_nb_context);
+        _size_depth                = max<uint32_t>(size_depth,_nb_context);
+        _size_inst_ifetch_ptr      = log2(max<uint32_t>(_nb_instruction,_nb_context));
     for (uint32_t i=0; i<_nb_context; i++)
+      {
         _size_inst_ifetch_ptr      [i] = log2(_nb_instruction [i]);
+        _have_port_depth           [i] = (_size_depth [i] > 0);
         _have_port_inst_ifetch_ptr [i] = (_size_inst_ifetch_ptr [i] > 0);
+        _have_port_context_id      = (_size_context_id > 0);
+        _have_port_depth           = (_size_depth > 0);
+        _have_port_inst_ifetch_ptr = (_size_inst_ifetch_ptr > 0);
+        copy ();
+      }
-    test();
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
   };
 …
+  {
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
+    delete  [] _size_inst_ifetch_ptr     ;
+    delete  [] _have_port_depth          ;
+    delete  [] _have_port_inst_ifetch_ptr;
+    log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Prediction_unit_Glue::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Parameters_print.cpp

-              r82
+              r88
     xml.singleton_begin("nb_decod_unit         "); xml.attribut("value",toString(_nb_decod_unit         )); xml.singleton_end();
 //     xml.singleton_begin("nb_ooo_engine         "); xml.attribut("value",toString(_nb_ooo_engine         )); xml.singleton_end();
     xml.singleton_begin("size_address          "); xml.attribut("value",toString(_size_address          )); xml.singleton_end();
+//  xml.singleton_begin("size_address          "); xml.attribut("value",toString(_size_address          )); xml.singleton_end();
     xml.singleton_begin("nb_inst_branch_predict"); xml.attribut("value",toString(_nb_inst_branch_predict)); xml.singleton_end();
     xml.singleton_begin("nb_inst_branch_decod  "); xml.attribut("value",toString(_nb_inst_branch_decod  )); xml.singleton_end();
 …
         xml.  attribut("id"  ,toString(i));
         xml. balise_open_end();
         xml.  singleton_begin("nb_instruction        "); xml.attribut("value",toString(_nb_instruction        [i])); xml.singleton_end();
         xml.  singleton_begin("size_depth            "); xml.attribut("value",toString(_size_depth            [i])); xml.singleton_end();
+        xml.  singleton_begin("nb_instruction        "); xml.attribut("value",toString(_nb_instruction        [i])); xml.singleton_end();
+//      xml.  singleton_begin("size_depth            "); xml.attribut("value",toString(_size_depth            [i])); xml.singleton_end();
         xml. balise_close();
+      }
 …
         xml.  attribut("id"  ,toString(i));
         xml. balise_open_end();
         xml.  singleton_begin("nb_inst_decod         "); xml.attribut("value",toString(_nb_inst_decod         [i])); xml.singleton_end();
+        xml.  singleton_begin("nb_inst_decod         "); xml.attribut("value",toString(_nb_inst_decod         [i])); xml.singleton_end();
         xml. balise_close();
+      }
 …
 //         xml.  attribut("id"  ,toString(i));
 //         xml. balise_open_end();
 //      xml.  singleton_begin("nb_inst_update        "); xml.attribut("value",toString(_nb_inst_update        [i])); xml.singleton_end();
+//      xml.  singleton_begin("nb_inst_update        "); xml.attribut("value",toString(_nb_inst_update        [i])); xml.singleton_end();
 //         xml. balise_close();
 //       }
 …
 #define FUNCTION "Prediction_unit_Glue::operator<<"
   std::ostream& operator<< (std::ostream& output_stream ,
                             morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::prediction_unit_glue::Parameters & x)
+                            morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::prediction_unit_glue::Parameters & x)
+  {
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue.cpp

-              r82
+              r88
     usage_environment(_usage);
+#if DEBUG_Prediction_unit_Glue == true
+    log_printf(INFO,Prediction_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Allocation");
     allocation (
 #ifdef STATISTICS
                 param_statistics
+                param_statistics
 #endif
                 );
+                );
 #ifdef STATISTICS
     if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Allocation of statistics");
         statistics_allocation(param_statistics);
+      {
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Allocation of statistics");
+        statistics_allocation(param_statistics);
+      }
 #endif
 …
     if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
         log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Generate the vhdl");
         vhdl();
+        // generate the vhdl
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Generate the vhdl");
+        vhdl();
+      }
 #endif
 …
     if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - transition");
         SC_METHOD (transition);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).pos();
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - transition");
+        SC_METHOD (transition);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).pos();
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
+        // List dependency information
 # endif
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_predict");
+        SC_METHOD (genMealy_predict);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            sensitive << (*( in_PREDICT_VAL                         [i]))
+                      << (*( in_PREDICT_PC_PREVIOUS                 [i]))
+                      << (*( in_PREDICT_PC_CURRENT                  [i]))
+                      << (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+          }
+        for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+          {
+            sensitive << (*( in_PREDICT_BTB_ACK              [i]))
+                      << (*( in_PREDICT_BTB_HIT              [i]))
+                      << (*( in_PREDICT_BTB_ADDRESS_SRC      [i]))
+                      << (*( in_PREDICT_BTB_ADDRESS_DEST     [i]))
+                      << (*( in_PREDICT_BTB_CONDITION        [i]))
+//                    << (*( in_PREDICT_BTB_LAST_TAKE        [i]))
+                      << (*( in_PREDICT_BTB_IS_ACCURATE      [i]))
+                      << (*( in_PREDICT_DIR_ACK              [i]))
+//                    << (*( in_PREDICT_DIR_HISTORY          [i]))
+                      << (*( in_PREDICT_DIR_DIRECTION        [i]))
+                      << (*( in_PREDICT_RAS_ACK              [i]))
+                      << (*( in_PREDICT_RAS_HIT              [i]))
+                      << (*( in_PREDICT_RAS_ADDRESS_POP      [i]))
+//                    << (*( in_PREDICT_RAS_INDEX            [i]))
+                      << (*( in_PREDICT_UPT_ACK              [i]));
+          }
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            sensitive << (*(in_DEPTH_UPT_NB_BRANCH [i]));
+            if (_param->_have_port_depth[i])
+              sensitive << (*(in_DEPTH_UPT_TAIL      [i]));
+          }
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_predict");
+        SC_METHOD (genMealy_predict);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            sensitive << (*( in_PREDICT_VAL                         [i]))
+                      << (*( in_PREDICT_PC_PREVIOUS                 [i]))
+                      << (*( in_PREDICT_PC_CURRENT                  [i]))
+                      << (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+          }
+        for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+          {
+            sensitive << (*( in_PREDICT_BTB_ACK              [i]))
+                      << (*( in_PREDICT_BTB_HIT              [i]))
+                      << (*( in_PREDICT_BTB_ADDRESS_SRC      [i]))
+                      << (*( in_PREDICT_BTB_ADDRESS_DEST     [i]))
+                      << (*( in_PREDICT_BTB_CONDITION        [i]))
+//                    << (*( in_PREDICT_BTB_LAST_TAKE        [i]))
+                      << (*( in_PREDICT_BTB_IS_ACCURATE      [i]))
+                      << (*( in_PREDICT_DIR_ACK              [i]))
+//                    << (*( in_PREDICT_DIR_HISTORY          [i]))
+                      << (*( in_PREDICT_DIR_DIRECTION        [i]))
+                      << (*( in_PREDICT_RAS_ACK              [i]))
+                      << (*( in_PREDICT_RAS_HIT              [i]))
+                      << (*( in_PREDICT_RAS_ADDRESS_POP      [i]))
+//                    << (*( in_PREDICT_RAS_INDEX            [i]))
+                      << (*( in_PREDICT_UPT_ACK              [i]));
+            if (_param->_have_port_depth)
+            sensitive << (*( in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID [i]));
+          }
+//      for (uint32_t i=0; i<_param->_nb_context; i++)
+//        {
+//          sensitive << (*(in_DEPTH_UPT_NB_BRANCH [i]));
+//          if (_param->_have_port_depth)
+//            sensitive << (*(in_DEPTH_UPT_TAIL      [i]));
+//        }
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
         for (uint32_t x=0; x<_param->_nb_context; x++)
+          {
             if (_param->_have_port_depth[x])
+              {
                 (*(out_DEPTH_TAIL                          [x])) (*( in_DEPTH_UPT_TAIL                      [x]));
+              }
                 (*(out_DEPTH_NB_BRANCH                     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [x]));
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_ACK                         [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_ACK                         [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             if (_param->_have_port_inst_ifetch_ptr [x])
+              {
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             if (_param->_have_port_depth [x])
+              {
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth [i])
+                  {
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
+              }
             for (uint32_t y=0; y<_param->_nb_instruction[x]; y++)
+              {
                 for (uint32_t i=0; i<_param->_nb_context; i++)
+                  {
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_VAL                         [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_CURRENT                  [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                     if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                      {
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                      }
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+                  }
                 for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+                  {
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ACK              [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_HIT              [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //                  (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_DIR_ACK              [i]));
 //                  (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_DIR_HISTORY          [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_ACK              [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_HIT              [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //                  (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_INDEX            [i]));
                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_UPT_ACK              [i]));
+                  }
+              }
+          }
         for (uint32_t x=0; x<_param->_nb_inst_branch_predict; x++)
+          {
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             if (_param->_have_port_context_id)
+              {
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
 //          for (uint32_t i=0; i<_param->_nb_context; i++)
 //            {
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_VAL                         [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
 //              if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
 //                {
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
 //                }
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
 //            }
 //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
 //            {
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ACK              [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_HIT              [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 // //           (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_DIR_ACK              [i]));
 // //           (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_ACK              [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_HIT              [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 // //           (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_INDEX            [i]));
 //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_UPT_ACK              [i]));
 //            }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             if (_param->_have_port_context_id)
+              {
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             if (_param->_have_port_context_id)
+              {
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
 //          for (uint32_t i=0; i<_param->_nb_context; i++)
 //            {
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_VAL                         [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
 //              if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
 //                {
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
 //                }
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
 //            }
 //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
 //            {
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ACK              [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_HIT              [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 // //           (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_DIR_ACK              [i]));
 // //           (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_ACK              [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_HIT              [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 // //           (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_INDEX            [i]));
 //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_UPT_ACK              [i]));
 //            }
             for (uint32_t i=0; i<_param->_nb_context; i++)
+              {
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_VAL                         [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
                 if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
+                  {
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+                  }
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+              }
             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+              {
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ACK              [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_HIT              [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 //              (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_DIR_ACK              [i]));
 //              (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_ACK              [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_HIT              [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 //              (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_INDEX            [i]));
                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_UPT_ACK              [i]));
+              }
 //          for (uint32_t i=0; i<_param->_nb_context; i++)
 //            {
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_VAL                         [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
 //              if (_param->_have_port_depth[x] and _param->_have_port_depth[i])
 //                {
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
 //                }
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
 //            }
 //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
 //            {
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ACK              [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_HIT              [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
 // //           (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_DIR_ACK              [i]));
 // //           (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_ACK              [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_HIT              [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
 // //           (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_INDEX            [i]));
 //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_UPT_ACK              [i]));
 //            }
+          }
+        // List dependency information
+//         for (uint32_t x=0; x<_param->_nb_context; x++)
+//           {
+// //          if (_param->_have_port_depth)
+// //            {
+// //              (*(out_DEPTH_TAIL                          [x])) (*( in_DEPTH_UPT_TAIL                      [x]));
+// //            }
+// //              (*(out_DEPTH_NB_BRANCH                     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [x]));
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_ACK                         [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_ACK                         [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_ACK                         [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_PC_NEXT                     [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_PC_NEXT_IS_DS_TAKE          [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             if (_param->_have_port_inst_ifetch_ptr)
+//               {
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_INST_IFETCH_PTR             [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_BRANCH_STATE                [x]))(*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_BRANCH_STATE                [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+// //          if (_param->_have_port_depth)
+// //            {
+// //          for (uint32_t i=0; i<_param->_nb_context; i++)
+// //            {
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_VAL                         [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //              if (_param->_have_port_depth)
+// //                {
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                }
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+// //            }
+// //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+// //            {
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ACK              [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_HIT              [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// ////            (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// ////            (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_ACK              [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_HIT              [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// ////            (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+// //              (*(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [x])) (*( in_PREDICT_UPT_ACK              [i]));
+// //            }
+// //            }
+//             for (uint32_t y=0; y<_param->_nb_instruction[x]; y++)
+//               {
+//                 for (uint32_t i=0; i<_param->_nb_context; i++)
+//                   {
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_VAL                         [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                     if (_param->_have_port_depth and _param->_have_port_depth)
+// //                       {
+// //                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                       }
+// //                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//                   }
+//                 for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//                   {
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ACK              [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_HIT              [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //                  (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_DIR_ACK              [i]));
+// //                  (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_ACK              [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_HIT              [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //                  (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                     (*(out_PREDICT_INSTRUCTION_ENABLE          [x][y])) (*( in_PREDICT_UPT_ACK              [i]));
+//                   }
+//               }
+//           }
+//         for (uint32_t x=0; x<_param->_nb_inst_branch_predict; x++)
+//           {
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_BTB_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             if (_param->_have_port_context_id)
+//               {
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_BTB_CONTEXT_ID       [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_BTB_ADDRESS          [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_DIR_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_DIR_ADDRESS_SRC      [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_DIR_STATIC           [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+// //          for (uint32_t i=0; i<_param->_nb_context; i++)
+// //            {
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_VAL                         [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //              if (_param->_have_port_depth and _param->_have_port_depth)
+// //                {
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                }
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+// //            }
+// //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+// //            {
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ACK              [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_HIT              [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// // //           (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// // //           (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_ACK              [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_HIT              [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// // //           (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+// //              (*(out_PREDICT_DIR_LAST_TAKE        [x])) (*( in_PREDICT_UPT_ACK              [i]));
+// //            }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //                 if (_param->_have_port_depth and _param->_have_port_depth)
+// //                   {
+// //                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                   }
+// //                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_RAS_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             if (_param->_have_port_context_id)
+//               {
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_RAS_CONTEXT_ID       [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_RAS_PUSH             [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_RAS_ADDRESS_PUSH     [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_VAL              [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             if (_param->_have_port_context_id)
+//               {
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_CONTEXT_ID       [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_SRC  [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_BTB_ADDRESS_DEST [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_BTB_CONDITION    [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_BTB_LAST_TAKE    [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_BTB_IS_ACCURATE  [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+// //          for (uint32_t i=0; i<_param->_nb_context; i++)
+// //            {
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_VAL                         [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //              if (_param->_have_port_depth and _param->_have_port_depth)
+// //                {
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                }
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+// //            }
+// //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+// //            {
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ACK              [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_HIT              [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// // //           (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// // //           (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_ACK              [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_HIT              [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// // //           (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+// //              (*(out_PREDICT_UPT_DIR_HISTORY      [x])) (*( in_PREDICT_UPT_ACK              [i]));
+// //            }
+//             for (uint32_t i=0; i<_param->_nb_context; i++)
+//               {
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_VAL                         [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+//                 if (_param->_have_port_depth and _param->_have_port_depth)
+//                   {
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+//                   }
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+//               }
+//             for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+//               {
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ACK              [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_HIT              [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// //              (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// //              (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_ACK              [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_HIT              [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// //              (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+//                 (*(out_PREDICT_UPT_RAS_ADDRESS      [x])) (*( in_PREDICT_UPT_ACK              [i]));
+//               }
+// //          for (uint32_t i=0; i<_param->_nb_context; i++)
+// //            {
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_VAL                         [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_PREVIOUS                 [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_CURRENT                  [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_PC_CURRENT_IS_DS_TAKE       [i]));
+// //              if (_param->_have_port_depth and _param->_have_port_depth)
+// //                {
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_DEPTH_UPT_TAIL                      [i]));
+// //                }
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_DEPTH_UPT_NB_BRANCH                 [i]));
+// //            }
+// //          for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+// //            {
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ACK              [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_HIT              [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ADDRESS_SRC      [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_ADDRESS_DEST     [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_CONDITION        [i]));
+// // //           (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_LAST_TAKE        [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_BTB_IS_ACCURATE      [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_DIR_ACK              [i]));
+// // //           (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_DIR_HISTORY          [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_DIR_DIRECTION        [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_ACK              [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_HIT              [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_ADDRESS_POP      [i]));
+// // //           (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_RAS_INDEX            [i]));
+// //              (*(out_PREDICT_UPT_RAS_INDEX        [x])) (*( in_PREDICT_UPT_ACK              [i]));
+// //            }
+//           }
 # endif
         log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_decod");
         SC_METHOD (genMealy_decod);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg(); // use internal register
         for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
           for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+            {
               sensitive << (*(in_DECOD_VAL                         [i][j]))
                         << (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]))
                         << (*(in_DECOD_BRANCH_STATE                [i][j]))
                         << (*(in_DECOD_BRANCH_CONDITION            [i][j]))
                         << (*(in_DECOD_BRANCH_DIRECTION            [i][j]))
                         << (*(in_DECOD_ADDRESS_SRC                 [i][j]))
                         << (*(in_DECOD_ADDRESS_DEST                [i][j]));
               if (_param->_have_port_context_id)
                 sensitive << (*(in_DECOD_CONTEXT_ID                  [i][j]));
               if (_param->_have_port_max_depth)
                 sensitive << (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+            }
         for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+          {
             sensitive << (*(in_DECOD_BTB_ACK                     [i]   ))
                       << (*(in_DECOD_RAS_ACK                     [i]   ))
                       << (*(in_DECOD_RAS_HIT                     [i]   ))
                       << (*(in_DECOD_RAS_ADDRESS_POP             [i]   ))
 //                    << (*(in_DECOD_RAS_INDEX                   [i]   ))
                       << (*(in_DECOD_UPT_ACK                     [i]   )) ;
+          }
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_decod");
+        SC_METHOD (genMealy_decod);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
+        for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+            {
+              sensitive << (*(in_DECOD_VAL                         [i][j]))
+                        << (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]))
+                        << (*(in_DECOD_BRANCH_STATE                [i][j]))
+                        << (*(in_DECOD_BRANCH_CONDITION            [i][j]))
+                        << (*(in_DECOD_BRANCH_DIRECTION            [i][j]))
+                        << (*(in_DECOD_ADDRESS_SRC                 [i][j]))
+                        << (*(in_DECOD_ADDRESS_DEST                [i][j]));
+              if (_param->_have_port_context_id)
+                sensitive << (*(in_DECOD_CONTEXT_ID                  [i][j]));
+              if (_param->_have_port_depth)
+                sensitive << (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+            }
+        for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+          {
+            sensitive << (*(in_DECOD_BTB_ACK                     [i]   ))
+                      << (*(in_DECOD_RAS_ACK                     [i]   ))
+                      << (*(in_DECOD_RAS_HIT                     [i]   ))
+                      << (*(in_DECOD_RAS_ADDRESS_POP             [i]   ))
+//                    << (*(in_DECOD_RAS_INDEX                   [i]   ))
+                      << (*(in_DECOD_UPT_ACK                     [i]   )) ;
+          }
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
         for (uint32_t x=0; x<_param->_nb_decod_unit; x++)
           for (uint32_t y=0; y<_param->_nb_inst_decod[x]; y++)
+            {
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                }
+            }
         for (uint32_t x=0; x<_param->_nb_inst_branch_decod; x++)
+          {
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               if (_param->_have_port_context_id)
+                {
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                }
+                }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               if (_param->_have_port_context_id)
+                {
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
+                }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               if (_param->_have_port_context_id)
+                {
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
+                }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
 //            for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
 //              for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
 //                {
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_VAL                         [i][j]));
 //                  if (_param->_have_port_context_id)
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
 //                  if (_param->_have_port_max_depth)
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
 //                }
 //            for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
 //              {
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
 //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
 //                }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     if (_param->_have_port_max_depth)
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                  }
               if (_param->_have_port_max_depth)
+                {
               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+                  {
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_VAL                         [i][j]));
                     if (_param->_have_port_context_id)
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+                  }
               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+                {
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
 //                  (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+                }
+                }
+          }
+//         // List dependency information
+//         for (uint32_t x=0; x<_param->_nb_decod_unit; x++)
+//           for (uint32_t y=0; y<_param->_nb_inst_decod[x]; y++)
+//             {
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_ACK                      [x][y])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                 }
+//             }
+//         for (uint32_t x=0; x<_param->_nb_inst_branch_decod; x++)
+//           {
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               if (_param->_have_port_context_id)
+//                 {
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                 }
+//                 }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_SRC          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_ADDRESS_DEST         [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_CONDITION            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_LAST_TAKE            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_MISS_PREDICTION      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_BTB_IS_ACCURATE          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_RAS_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               if (_param->_have_port_context_id)
+//                 {
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_RAS_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//                 }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_RAS_PUSH                 [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_RAS_ADDRESS_PUSH         [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_RAS_MISS_PREDICTION      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_VAL                  [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               if (_param->_have_port_context_id)
+//                 {
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_CONTEXT_ID           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//                 }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_SRC      [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_BTB_ADDRESS_DEST     [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_BTB_CONDITION        [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_BTB_LAST_TAKE        [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_RAS_ADDRESS          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+// //            for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+// //              for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+// //                {
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_VAL                         [i][j]));
+// //                  if (_param->_have_port_context_id)
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+// //                  if (_param->_have_port_depth)
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+// //                }
+// //            for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+// //              {
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+// //                  (*(out_DECOD_UPT_RAS_INDEX            [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+// //                }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_MISS_IFETCH          [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     if (_param->_have_port_depth)
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_MISS_DECOD           [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                   }
+//               if (_param->_have_port_depth)
+//                 {
+//               for (uint32_t i=0; i<_param->_nb_decod_unit; i++)
+//                 for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+//                   {
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_VAL                         [i][j]));
+//                     if (_param->_have_port_context_id)
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_CONTEXT_ID                  [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_MATCH_INST_IFETCH_PTR       [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_STATE                [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_CONDITION            [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BRANCH_DIRECTION            [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_ADDRESS_SRC                 [i][j]));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_ADDRESS_DEST                [i][j]));
+//                   }
+//               for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+//                 {
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_BTB_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_ACK                     [i]   ));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_HIT                     [i]   ));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_ADDRESS_POP             [i]   ));
+// //                  (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_RAS_INDEX                   [i]   ));
+//                     (*(out_DECOD_UPT_UPDATE_PREDICTION_ID [x])) (*(in_DECOD_UPT_ACK                     [i]   ));
+//                 }
+//                 }
+//           }
 # endif
         log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_update");
         SC_METHOD (genMealy_update);
         dont_initialize ();
 //      sensitive << (*(in_CLOCK)).neg(); // don't use internal register
         for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
           sensitive << (*(in_UPDATE_BTB_ACK           [i]))
                     << (*(in_UPDATE_DIR_ACK           [i]))
                     << (*(in_UPDATE_RAS_ACK           [i]))
                     << (*(in_UPDATE_UPT_VAL           [i]))
                     << (*(in_UPDATE_UPT_BTB_VAL       [i]))
                     << (*(in_UPDATE_UPT_DIR_VAL       [i]))
                     << (*(in_UPDATE_UPT_RAS_VAL       [i]));
+        log_printf(INFO,Prediction_unit_Glue,FUNCTION,"Method - genMealy_update");
+        SC_METHOD (genMealy_update);
+        dont_initialize ();
+//      sensitive << (*(in_CLOCK)).neg(); // don't use internal register
+        for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
+          sensitive << (*(in_UPDATE_BTB_ACK           [i]))
+                    << (*(in_UPDATE_DIR_ACK           [i]))
+                    << (*(in_UPDATE_RAS_ACK           [i]))
+                    << (*(in_UPDATE_UPT_VAL           [i]))
+                    << (*(in_UPDATE_UPT_BTB_VAL       [i]))
+                    << (*(in_UPDATE_UPT_DIR_VAL       [i]))
+                    << (*(in_UPDATE_UPT_RAS_VAL       [i]));
 # ifdef SYSTEMCASS_SPECIFIC
         // List dependency information
         for (uint32_t x=0; x<_param->_nb_inst_branch_update; x++)
 //        for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
+            {
               uint32_t i=x;
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_BTB_ACK           [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_DIR_ACK           [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_RAS_ACK           [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_VAL           [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
+            }
+//         // List dependency information
+//         for (uint32_t x=0; x<_param->_nb_inst_branch_update; x++)
+// //        for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
+//             {
+//               uint32_t i=x;
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
+//               (*(out_UPDATE_BTB_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
+//               (*(out_UPDATE_DIR_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_BTB_ACK           [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_DIR_ACK           [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_RAS_ACK           [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_VAL           [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
+//               (*(out_UPDATE_RAS_VAL           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_BTB_ACK           [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_DIR_ACK           [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_RAS_ACK           [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_VAL           [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_BTB_VAL       [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_DIR_VAL       [i]));
+//               (*(out_UPDATE_UPT_ACK           [x])) (*(in_UPDATE_UPT_RAS_VAL       [i]));
+//             }
 # endif
 #endif
 …
     if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();
+        statistics_deallocation();
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_allocation.cpp

-              r82
+              r88
     Entity * entity = _component->set_entity (_name
                                               ,"Prediction_unit_Glue"
+                                              ,"Prediction_unit_Glue"
 #ifdef POSITION
                                               ,COMBINATORY
 #endif
                                               );
+                                              ,COMBINATORY
+#endif
+                                              );
     _interfaces = entity->set_interfaces();
 …
       Interface * interface = _interfaces->set_interface(""
 #ifdef POSITION
                                                          ,IN
                                                          ,SOUTH,
                                                          "Generalist interface"
 #endif
                                                          );
+                                                         ,IN
+                                                         ,SOUTH,
+                                                         "Generalist interface"
+#endif
+                                                         );
       in_CLOCK        = interface->set_signal_clk              ("clock" ,1, CLOCK_VHDL_YES);
 …
+    {
+      {
         ALLOC1_INTERFACE("predict",IN,SOUTH,"Interface with ifetch unit",_param->_nb_context);
         ALLOC1_VALACK_IN ( in_PREDICT_VAL                        ,VAL);
         ALLOC1_VALACK_OUT(out_PREDICT_ACK                        ,ACK);
         ALLOC1_SIGNAL_IN ( in_PREDICT_PC_PREVIOUS                ,"pc_previous"                ,Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_IN ( in_PREDICT_PC_CURRENT                 ,"pc_current"                 ,Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_IN ( in_PREDICT_PC_CURRENT_IS_DS_TAKE      ,"pc_current_is_ds_take"      ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_PC_NEXT                    ,"pc_next"                    ,Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_OUT(out_PREDICT_PC_NEXT_IS_DS_TAKE         ,"pc_next_is_ds_take"         ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr [alloc_signal_it1]);
         ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state);
         ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth [alloc_signal_it1]);
+      }
+      {
         ALLOC2_INTERFACE("predict",IN,SOUTH,"Interface with ifetch unit",_param->_nb_context,_param->_nb_instruction[alloc_interface_it1]);
         _ALLOC2_SIGNAL_OUT(out_PREDICT_INSTRUCTION_ENABLE         ,"instruction_enable"         ,Tcontrol_t         ,1,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+      }
+      {
         ALLOC1_INTERFACE("predict_btb",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
         ALLOC1_VALACK_OUT(out_PREDICT_BTB_VAL         ,VAL);
         ALLOC1_VALACK_IN ( in_PREDICT_BTB_ACK         ,ACK);
         ALLOC1_SIGNAL_OUT(out_PREDICT_BTB_CONTEXT_ID  ,"context_id"  ,Tcontext_t         ,_param->_size_context_id);
         ALLOC1_SIGNAL_OUT(out_PREDICT_BTB_ADDRESS     ,"address"     ,Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_HIT         ,"hit"         ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_SRC ,"address_src" ,Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_DEST,"address_dest",Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_CONDITION   ,"condition"   ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_INTERFACE("predict",IN,SOUTH,"Interface with ifetch unit",_param->_nb_context);
+        ALLOC1_VALACK_IN ( in_PREDICT_VAL                        ,VAL);
+        ALLOC1_VALACK_OUT(out_PREDICT_ACK                        ,ACK);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_PC_PREVIOUS                ,"pc_previous"                ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_PC_CURRENT                 ,"pc_current"                 ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_PC_CURRENT_IS_DS_TAKE      ,"pc_current_is_ds_take"      ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_PC_NEXT                    ,"pc_next"                    ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_PC_NEXT_IS_DS_TAKE         ,"pc_next_is_ds_take"         ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+      }
+      {
+        ALLOC2_INTERFACE("predict",IN,SOUTH,"Interface with ifetch unit",_param->_nb_context,_param->_nb_instruction[it1]);
+        _ALLOC2_SIGNAL_OUT(out_PREDICT_INSTRUCTION_ENABLE         ,"instruction_enable"         ,Tcontrol_t         ,1,_param->_nb_context,_param->_nb_instruction[it1]);
+      }
+      {
+        ALLOC1_INTERFACE("predict_btb",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
+        ALLOC1_VALACK_OUT(out_PREDICT_BTB_VAL         ,VAL);
+        ALLOC1_VALACK_IN ( in_PREDICT_BTB_ACK         ,ACK);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_BTB_CONTEXT_ID  ,"context_id"  ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_BTB_ADDRESS     ,"address"     ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_HIT         ,"hit"         ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_SRC ,"address_src" ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_DEST,"address_dest",Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_CONDITION   ,"condition"   ,Tbranch_condition_t,_param->_size_branch_condition);
 //      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_LAST_TAKE   ,"last_take"   ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_IS_ACCURATE ,"is_accurate" ,Tcontrol_t         ,1);
+      }
+      {
         ALLOC1_INTERFACE("predict_dir",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
         ALLOC1_VALACK_OUT(out_PREDICT_DIR_VAL        ,VAL);
         ALLOC1_VALACK_IN ( in_PREDICT_DIR_ACK        ,ACK);
         ALLOC1_SIGNAL_OUT(out_PREDICT_DIR_ADDRESS_SRC,"address_src",Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_OUT(out_PREDICT_DIR_STATIC     ,"static"     ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_IS_ACCURATE ,"is_accurate" ,Tcontrol_t         ,1);
+      }
+      {
+        ALLOC1_INTERFACE("predict_dir",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
+        ALLOC1_VALACK_OUT(out_PREDICT_DIR_VAL        ,VAL);
+        ALLOC1_VALACK_IN ( in_PREDICT_DIR_ACK        ,ACK);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_DIR_ADDRESS_SRC,"address_src",Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_DIR_STATIC     ,"static"     ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_OUT(out_PREDICT_DIR_LAST_TAKE  ,"last_take"  ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_IN ( in_PREDICT_DIR_HISTORY    ,"history"    ,Thistory_t         ,_param->_size_history);
         ALLOC1_SIGNAL_IN ( in_PREDICT_DIR_DIRECTION  ,"direction"  ,Tcontrol_t         ,1);
+      }
+      {
         ALLOC1_INTERFACE("predict_ras",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
         ALLOC1_VALACK_OUT(out_PREDICT_RAS_VAL         ,VAL);
         ALLOC1_VALACK_IN ( in_PREDICT_RAS_ACK         ,ACK);
         ALLOC1_SIGNAL_OUT(out_PREDICT_RAS_CONTEXT_ID  ,"context_id"  ,Tcontext_t         ,_param->_size_context_id);
         ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_HIT         ,"hit"         ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_RAS_PUSH        ,"push"        ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_RAS_ADDRESS_PUSH,"address_push",Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_ADDRESS_POP ,"address_pop" ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_DIR_DIRECTION  ,"direction"  ,Tcontrol_t         ,1);
+      }
+      {
+        ALLOC1_INTERFACE("predict_ras",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
+        ALLOC1_VALACK_OUT(out_PREDICT_RAS_VAL         ,VAL);
+        ALLOC1_VALACK_IN ( in_PREDICT_RAS_ACK         ,ACK);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_RAS_CONTEXT_ID  ,"context_id"  ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_HIT         ,"hit"         ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_RAS_PUSH        ,"push"        ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_RAS_ADDRESS_PUSH,"address_push",Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_ADDRESS_POP ,"address_pop" ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_INDEX       ,"index"       ,Tptr_t             ,_param->_size_ras_index);
+      }
+      {
+        ALLOC1_INTERFACE("predict_upt",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
+        ALLOC1_VALACK_OUT(out_PREDICT_UPT_VAL             ,VAL);
+        ALLOC1_VALACK_IN ( in_PREDICT_UPT_ACK             ,ACK);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_CONTEXT_ID      ,"context_id"      ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_ADDRESS_SRC ,"btb_address_src" ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_ADDRESS_DEST,"btb_address_dest",Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_CONDITION   ,"btb_condition"   ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_LAST_TAKE   ,"btb_last_take"   ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_IS_ACCURATE ,"btb_is_accurate" ,Tcontrol_t         ,1);
+        ALLOC1_INTERFACE("predict_upt",OUT,NORTH,"Interface with ifetch unit",_param->_nb_inst_branch_predict);
+        ALLOC1_VALACK_OUT(out_PREDICT_UPT_VAL             ,VAL);
+        ALLOC1_VALACK_IN ( in_PREDICT_UPT_ACK             ,ACK);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_CONTEXT_ID      ,"context_id"      ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_IN ( in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_ADDRESS_SRC ,"btb_address_src" ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_ADDRESS_DEST,"btb_address_dest",Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_CONDITION   ,"btb_condition"   ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_LAST_TAKE   ,"btb_last_take"   ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_BTB_IS_ACCURATE ,"btb_is_accurate" ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_DIR_HISTORY     ,"dir_history"     ,Thistory_t         ,_param->_size_history);
         ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_RAS_ADDRESS     ,"ras_address"     ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_RAS_ADDRESS     ,"ras_address"     ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_OUT(out_PREDICT_UPT_RAS_INDEX       ,"ras_index"       ,Tptr_t             ,_param->_size_ras_index);
+      }
+    }
+    // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      {
+        ALLOC2_INTERFACE("decod",IN,SOUTH,"Interface with decod unit",_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_interface_it1]);
+        _ALLOC2_VALACK_IN ( in_DECOD_VAL                        ,VAL,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_VALACK_OUT(out_DECOD_ACK                        ,ACK,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_max_size_depth       ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_SRC                ,"address_src"                ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_DEST               ,"address_dest"               ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+      }
+      {
+        ALLOC1_INTERFACE("decod_btb",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
+        ALLOC1_VALACK_OUT(out_DECOD_BTB_VAL            ,VAL);
+        ALLOC1_VALACK_IN ( in_DECOD_BTB_ACK            ,ACK);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_ADDRESS_SRC    ,"address_src"    ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_ADDRESS_DEST   ,"address_dest"   ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_MISS_PREDICTION,"miss_prediction",Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_IS_ACCURATE    ,"is_accurate"    ,Tcontrol_t         ,1);
+      }
+      {
+        ALLOC1_INTERFACE("decod_ras",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
+        ALLOC1_VALACK_OUT(out_DECOD_RAS_VAL            ,VAL);
+        ALLOC1_VALACK_IN ( in_DECOD_RAS_ACK            ,ACK);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
+        ALLOC1_SIGNAL_IN ( in_DECOD_RAS_HIT            ,"hit"            ,Tcontrol_t,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_PUSH           ,"push"           ,Tcontrol_t,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_ADDRESS_PUSH   ,"address_push"   ,Taddress_t,_param->_size_address);
+        ALLOC1_SIGNAL_IN ( in_DECOD_RAS_ADDRESS_POP    ,"address_pop"    ,Taddress_t,_param->_size_address);
+//      ALLOC1_SIGNAL_IN ( in_DECOD_RAS_INDEX          ,"index"          ,Tptr_t    ,_param->_size_ras_index);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
+      }
+      {
+        ALLOC1_INTERFACE("decod_upt",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
+        ALLOC1_VALACK_OUT(out_DECOD_UPT_VAL                 ,VAL);
+        ALLOC1_VALACK_IN ( in_DECOD_UPT_ACK                 ,ACK);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_address);
+//      ALLOC1_SIGNAL_OUT(out_DECOD_UPT_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_size_ras_index);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_MISS_IFETCH         ,"miss_ifetch"         ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_MISS_DECOD          ,"miss_decod"          ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_max_size_depth);
+      }
+    }
+    // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      {
+        ALLOC1_INTERFACE("update_btb",OUT,SOUTH,"Interface with update unit",_param->_nb_inst_branch_update);
+    // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      {
+        ALLOC2_INTERFACE("decod",IN,SOUTH,"Interface with decod unit",_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_VALACK_IN ( in_DECOD_VAL                        ,VAL,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_VALACK_OUT(out_DECOD_ACK                        ,ACK,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_SRC                ,"address_src"                ,Taddress_t         ,_param->_size_instruction_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_DEST               ,"address_dest"               ,Taddress_t         ,_param->_size_instruction_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+      }
+      {
+        ALLOC1_INTERFACE("decod_btb",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
+        ALLOC1_VALACK_OUT(out_DECOD_BTB_VAL            ,VAL);
+        ALLOC1_VALACK_IN ( in_DECOD_BTB_ACK            ,ACK);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_CONTEXT_ID     ,"context_id"     ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_ADDRESS_SRC    ,"address_src"    ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_ADDRESS_DEST   ,"address_dest"   ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_CONDITION      ,"condition"      ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_LAST_TAKE      ,"last_take"      ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_MISS_PREDICTION,"miss_prediction",Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_BTB_IS_ACCURATE    ,"is_accurate"    ,Tcontrol_t         ,1);
+      }
+      {
+        ALLOC1_INTERFACE("decod_ras",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
+        ALLOC1_VALACK_OUT(out_DECOD_RAS_VAL            ,VAL);
+        ALLOC1_VALACK_IN ( in_DECOD_RAS_ACK            ,ACK);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
+        ALLOC1_SIGNAL_IN ( in_DECOD_RAS_HIT            ,"hit"            ,Tcontrol_t,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_PUSH           ,"push"           ,Tcontrol_t,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_ADDRESS_PUSH   ,"address_push"   ,Taddress_t,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_IN ( in_DECOD_RAS_ADDRESS_POP    ,"address_pop"    ,Taddress_t,_param->_size_instruction_address);
+//      ALLOC1_SIGNAL_IN ( in_DECOD_RAS_INDEX          ,"index"          ,Tptr_t    ,_param->_size_ras_index);
+        ALLOC1_SIGNAL_OUT(out_DECOD_RAS_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
+      }
+      {
+        ALLOC1_INTERFACE("decod_upt",OUT,NORTH,"Interface with decod unit",_param->_nb_inst_branch_decod);
+        ALLOC1_VALACK_OUT(out_DECOD_UPT_VAL                 ,VAL);
+        ALLOC1_VALACK_IN ( in_DECOD_UPT_ACK                 ,ACK);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_instruction_address);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_instruction_address);
+//      ALLOC1_SIGNAL_OUT(out_DECOD_UPT_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_size_ras_index);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_MISS_IFETCH         ,"miss_ifetch"         ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_MISS_DECOD          ,"miss_decod"          ,Tcontrol_t         ,1);
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth    );
+        ALLOC1_SIGNAL_OUT(out_DECOD_UPT_IS_ACCURATE         ,"is_accurate"         ,Tcontrol_t         ,1);
+      }
+    }
+    // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
+      {
+        ALLOC1_INTERFACE("update_btb",OUT,SOUTH,"Interface with update unit",_param->_nb_inst_branch_update);
         ALLOC1_VALACK_OUT(out_UPDATE_BTB_VAL                  ,VAL);
         ALLOC1_VALACK_IN ( in_UPDATE_BTB_ACK                  ,ACK);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_CONTEXT_ID           ,"context_id"           ,Tcontext_t         ,_param->_size_context_id);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_SRC          ,"address_src"          ,Taddress_t         ,_param->_size_address);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_DEST         ,"address_dest"         ,Taddress_t         ,_param->_size_address);
+//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_SRC          ,"address_src"          ,Taddress_t         ,_param->_size_instruction_address);
+//      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_DEST         ,"address_dest"         ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_CONDITION            ,"condition"            ,Tbranch_condition_t,_param->_size_branch_condition);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_LAST_TAKE            ,"last_take"            ,Tcontrol_t         ,1);
 …
+      {
         ALLOC1_INTERFACE("update_dir",OUT,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
+        ALLOC1_INTERFACE("update_dir",OUT,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
         ALLOC1_VALACK_OUT(out_UPDATE_DIR_VAL                  ,VAL);
         ALLOC1_VALACK_IN ( in_UPDATE_DIR_ACK                  ,ACK);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_ADDRESS              ,"address"              ,Taddress_t         ,_param->_size_address);
+//      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_ADDRESS              ,"address"              ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_HISTORY              ,"history"              ,Thistory_t         ,_param->_size_history);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_DIRECTION            ,"direction"            ,Tcontrol_t         ,1);
 …
+      {
         ALLOC1_INTERFACE("update_ras",OUT,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
+        ALLOC1_INTERFACE("update_ras",OUT,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
         ALLOC1_VALACK_OUT(out_UPDATE_RAS_VAL                  ,VAL);
 …
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_CONTEXT_ID           ,"context_id"           ,Tcontext_t         ,_param->_size_context_id);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_PUSH                 ,"push"                 ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_ADDRESS              ,"address"              ,Taddress_t         ,_param->_size_address);
+//      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_ADDRESS              ,"address"              ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_INDEX                ,"index"                ,Tptr_t             ,_param->_size_ras_index);
 //      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_MISS_PREDICTION      ,"miss_prediction"      ,Tcontrol_t         ,1);
 …
+      {
         ALLOC1_INTERFACE("update_upt",IN ,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
+        ALLOC1_INTERFACE("update_upt",IN ,NORTH,"Interface with update unit",_param->_nb_inst_branch_update);
         ALLOC1_VALACK_IN ( in_UPDATE_UPT_VAL                  ,VAL);
 …
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_MISS_PREDICTION      ,"miss_prediction"      ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_DIRECTION_GOOD       ,"direction_good"       ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_VAL              ,"btb_val"              ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,"btb_address_src"      ,Taddress_t         ,_param->_size_address);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,"btb_address_dest"     ,Taddress_t         ,_param->_size_address);
+        ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_VAL              ,"btb_val"              ,Tcontrol_t         ,1);
+//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,"btb_address_src"      ,Taddress_t         ,_param->_size_instruction_address);
+//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,"btb_address_dest"     ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_BTB_CONDITION        ,"btb_condition"        ,Tbranch_condition_t,_param->_size_branch_condition);
         ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_DIR_VAL              ,"dir_val"              ,Tcontrol_t         ,1);
 …
         ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_VAL              ,"ras_val"              ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_PUSH             ,"ras_push"             ,Tcontrol_t         ,1);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_ADDRESS          ,"ras_address"          ,Taddress_t         ,_param->_size_address);
+//      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_ADDRESS          ,"ras_address"          ,Taddress_t         ,_param->_size_instruction_address);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_INDEX            ,"ras_index"            ,Tptr_t             ,_param->_size_ras_index);
 //      ALLOC1_SIGNAL_IN ( in_UPDATE_UPT_RAS_PREDICTION_IFETCH,"ras_prediction_ifetch",Tcontrol_t         ,1);
 …
+    }
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC1_INTERFACE("depth",IN,NORTH,"Interface with depth",_param->_nb_context);
       ALLOC1_SIGNAL_IN ( in_DEPTH_UPT_NB_BRANCH,"upt_nb_branch",Tdepth_t,_param->_size_depth[alloc_signal_it1]+1);
       ALLOC1_SIGNAL_IN ( in_DEPTH_UPT_TAIL     ,"upt_tail"     ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
       ALLOC1_SIGNAL_OUT(out_DEPTH_NB_BRANCH    ,"nb_branch"    ,Tdepth_t,_param->_size_depth[alloc_signal_it1]+1);
       ALLOC1_SIGNAL_OUT(out_DEPTH_TAIL         ,"tail"         ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
+    }
+//  // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//  {
+//    ALLOC1_INTERFACE("depth",IN,NORTH,"Interface with depth",_param->_nb_context);
+//
+//    ALLOC1_SIGNAL_IN ( in_DEPTH_UPT_NB_BRANCH,"upt_nb_branch",Tdepth_t,_param->_size_depth+1);
+//    ALLOC1_SIGNAL_IN ( in_DEPTH_UPT_TAIL     ,"upt_tail"     ,Tdepth_t,_param->_size_depth);
+//    ALLOC1_SIGNAL_OUT(out_DEPTH_NB_BRANCH    ,"nb_branch"    ,Tdepth_t,_param->_size_depth+1);
+//    ALLOC1_SIGNAL_OUT(out_DEPTH_TAIL         ,"tail"         ,Tdepth_t,_param->_size_depth);
+//  }
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#ifndef NO_INIT
+    reg_PREDICT_PRIORITY = 0;
+    reg_DECOD_PRIORITY   = 0;
+#ifndef REGISTER_INIT
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        reg_PREDICT_PRIORITY = 0;
+        reg_DECOD_PRIORITY   = 0;
+      }
 #endif
 …
 #ifdef POSITION
     if (usage_is_set(_usage,USE_POSITION))
         _component->generate_file();
+        _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_deallocation.cpp

-              r82
+              r88
         DELETE1_SIGNAL( in_PREDICT_VAL                        ,_param->_nb_context     ,1);
         DELETE1_SIGNAL(out_PREDICT_ACK                        ,_param->_nb_context     ,1);
         DELETE1_SIGNAL( in_PREDICT_PC_PREVIOUS                ,_param->_nb_context     ,_param->_size_address);
         DELETE1_SIGNAL( in_PREDICT_PC_CURRENT                 ,_param->_nb_context     ,_param->_size_address);
+        DELETE1_SIGNAL( in_PREDICT_PC_PREVIOUS                ,_param->_nb_context     ,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_PREDICT_PC_CURRENT                 ,_param->_nb_context     ,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_PREDICT_PC_CURRENT_IS_DS_TAKE      ,_param->_nb_context     ,1);
         DELETE1_SIGNAL(out_PREDICT_PC_NEXT                    ,_param->_nb_context     ,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_PC_NEXT                    ,_param->_nb_context     ,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_PREDICT_PC_NEXT_IS_DS_TAKE         ,_param->_nb_context     ,1);
         DELETE1_SIGNAL(out_PREDICT_INST_IFETCH_PTR            ,_param->_nb_context     ,_param->_size_inst_ifetch_ptr [alloc_signal_it1]);
+        DELETE1_SIGNAL(out_PREDICT_INST_IFETCH_PTR            ,_param->_nb_context     ,_param->_size_inst_ifetch_ptr);
         DELETE1_SIGNAL(out_PREDICT_BRANCH_STATE               ,_param->_nb_context     ,_param->_size_branch_state);
         DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context     ,_param->_size_depth [alloc_signal_it1]);
         DELETE2_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_context     ,_param->_nb_instruction[alloc_signal_it1],1);
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context     ,_param->_size_depth);
+        DELETE2_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_context     ,_param->_nb_instruction[it1],1);
         DELETE1_SIGNAL(out_PREDICT_BTB_VAL                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL( in_PREDICT_BTB_ACK                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL(out_PREDICT_BTB_CONTEXT_ID             ,_param->_nb_inst_branch_predict,_param->_size_context_id);
         DELETE1_SIGNAL(out_PREDICT_BTB_ADDRESS                ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_BTB_ADDRESS                ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_PREDICT_BTB_HIT                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC            ,_param->_nb_inst_branch_predict,_param->_size_address);
         DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST           ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_SRC            ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_PREDICT_BTB_ADDRESS_DEST           ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_PREDICT_BTB_CONDITION              ,_param->_nb_inst_branch_predict,_param->_size_branch_condition);
 //      DELETE1_SIGNAL( in_PREDICT_BTB_LAST_TAKE              ,_param->_nb_inst_branch_predict,1);
 …
         DELETE1_SIGNAL(out_PREDICT_DIR_VAL                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL( in_PREDICT_DIR_ACK                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC            ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_DIR_ADDRESS_SRC            ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_PREDICT_DIR_STATIC                 ,_param->_nb_inst_branch_predict,1);
 //      DELETE1_SIGNAL(out_PREDICT_DIR_LAST_TAKE              ,_param->_nb_inst_branch_predict,1);
 …
         DELETE1_SIGNAL( in_PREDICT_RAS_HIT                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL(out_PREDICT_RAS_PUSH                   ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH           ,_param->_nb_inst_branch_predict,_param->_size_address);
         DELETE1_SIGNAL( in_PREDICT_RAS_ADDRESS_POP            ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_RAS_ADDRESS_PUSH           ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_PREDICT_RAS_ADDRESS_POP            ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
 //      DELETE1_SIGNAL( in_PREDICT_RAS_INDEX                  ,_param->_nb_inst_branch_predict,_param->_size_ras_index);
         DELETE1_SIGNAL(out_PREDICT_UPT_VAL                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL( in_PREDICT_UPT_ACK                    ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL(out_PREDICT_UPT_CONTEXT_ID             ,_param->_nb_inst_branch_predict,_param->_size_context_id);
+        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC        ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST       ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL( in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_branch_predict,_param->_size_depth);
+        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_SRC        ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_PREDICT_UPT_BTB_ADDRESS_DEST       ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_CONDITION          ,_param->_nb_inst_branch_predict,_param->_size_branch_condition);
         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_LAST_TAKE          ,_param->_nb_inst_branch_predict,1);
         DELETE1_SIGNAL(out_PREDICT_UPT_BTB_IS_ACCURATE        ,_param->_nb_inst_branch_predict,1);
 //      DELETE1_SIGNAL(out_PREDICT_UPT_DIR_HISTORY            ,_param->_nb_inst_branch_predict,_param->_size_history);
         DELETE1_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS            ,_param->_nb_inst_branch_predict,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_UPT_RAS_ADDRESS            ,_param->_nb_inst_branch_predict,_param->_size_instruction_address);
 //      DELETE1_SIGNAL(out_PREDICT_UPT_RAS_INDEX              ,_param->_nb_inst_branch_predict,_param->_size_ras_index);
         // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         DELETE2_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1);
         DELETE2_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1);
         DELETE2_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_context_id      );
         DELETE2_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1                             );
         DELETE2_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_branch_state    );
         DELETE2_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_max_size_depth       );
         DELETE2_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_branch_condition);
         DELETE2_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1                             );
         DELETE2_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_address         );
         DELETE2_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_address         );
+        DELETE2_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1);
+        DELETE2_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1);
+        DELETE2_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_context_id      );
+        DELETE2_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1                             );
+        DELETE2_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_branch_state    );
+        DELETE2_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_depth           );
+        DELETE2_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_branch_condition);
+        DELETE2_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1                             );
+        DELETE2_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_instruction_address         );
+        DELETE2_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_instruction_address         );
         DELETE1_SIGNAL(out_DECOD_BTB_VAL            ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL( in_DECOD_BTB_ACK            ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL(out_DECOD_BTB_CONTEXT_ID     ,_param->_nb_inst_branch_decod,_param->_size_context_id);
         DELETE1_SIGNAL(out_DECOD_BTB_ADDRESS_SRC    ,_param->_nb_inst_branch_decod,_param->_size_address);
         DELETE1_SIGNAL(out_DECOD_BTB_ADDRESS_DEST   ,_param->_nb_inst_branch_decod,_param->_size_address);
+        DELETE1_SIGNAL(out_DECOD_BTB_ADDRESS_SRC    ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_DECOD_BTB_ADDRESS_DEST   ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_DECOD_BTB_CONDITION      ,_param->_nb_inst_branch_decod,_param->_size_branch_condition);
         DELETE1_SIGNAL(out_DECOD_BTB_LAST_TAKE      ,_param->_nb_inst_branch_decod,1);
 …
         DELETE1_SIGNAL( in_DECOD_RAS_HIT            ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL(out_DECOD_RAS_PUSH           ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL(out_DECOD_RAS_ADDRESS_PUSH   ,_param->_nb_inst_branch_decod,_param->_size_address);
         DELETE1_SIGNAL( in_DECOD_RAS_ADDRESS_POP    ,_param->_nb_inst_branch_decod,_param->_size_address);
+        DELETE1_SIGNAL(out_DECOD_RAS_ADDRESS_PUSH   ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_DECOD_RAS_ADDRESS_POP    ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
 //      DELETE1_SIGNAL( in_DECOD_RAS_INDEX          ,_param->_nb_inst_branch_decod,_param->_size_ras_index);
         DELETE1_SIGNAL(out_DECOD_RAS_MISS_PREDICTION,_param->_nb_inst_branch_decod,1);
 …
         DELETE1_SIGNAL( in_DECOD_UPT_ACK                 ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL(out_DECOD_UPT_CONTEXT_ID          ,_param->_nb_inst_branch_decod,_param->_size_context_id);
         DELETE1_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_SRC     ,_param->_nb_inst_branch_decod,_param->_size_address);
         DELETE1_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_DEST    ,_param->_nb_inst_branch_decod,_param->_size_address);
+        DELETE1_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_SRC     ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_DECOD_UPT_BTB_ADDRESS_DEST    ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_DECOD_UPT_BTB_CONDITION       ,_param->_nb_inst_branch_decod,_param->_size_branch_condition);
         DELETE1_SIGNAL(out_DECOD_UPT_BTB_LAST_TAKE       ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL(out_DECOD_UPT_RAS_ADDRESS         ,_param->_nb_inst_branch_decod,_param->_size_address);
+        DELETE1_SIGNAL(out_DECOD_UPT_RAS_ADDRESS         ,_param->_nb_inst_branch_decod,_param->_size_instruction_address);
 //      DELETE1_SIGNAL(out_DECOD_UPT_RAS_INDEX           ,_param->_nb_inst_branch_decod,_param->_size_ras_index);
         DELETE1_SIGNAL(out_DECOD_UPT_MISS_IFETCH         ,_param->_nb_inst_branch_decod,1);
         DELETE1_SIGNAL(out_DECOD_UPT_MISS_DECOD          ,_param->_nb_inst_branch_decod,1);
+        DELETE1_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID,_param->_nb_inst_branch_decod,_param->_max_size_depth);
+        DELETE1_SIGNAL(out_DECOD_UPT_UPDATE_PREDICTION_ID,_param->_nb_inst_branch_decod,_param->_size_depth);
+        DELETE1_SIGNAL(out_DECOD_UPT_IS_ACCURATE         ,_param->_nb_inst_branch_decod,1);
         // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
         DELETE1_SIGNAL( in_UPDATE_BTB_ACK                  ,_param->_nb_inst_branch_update,1);
 //      DELETE1_SIGNAL(out_UPDATE_BTB_CONTEXT_ID           ,_param->_nb_inst_branch_update,_param->_size_context_id);
 //      DELETE1_SIGNAL(out_UPDATE_BTB_ADDRESS_SRC          ,_param->_nb_inst_branch_update,_param->_size_address);
 //      DELETE1_SIGNAL(out_UPDATE_BTB_ADDRESS_DEST         ,_param->_nb_inst_branch_update,_param->_size_address);
+//      DELETE1_SIGNAL(out_UPDATE_BTB_ADDRESS_SRC          ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
+//      DELETE1_SIGNAL(out_UPDATE_BTB_ADDRESS_DEST         ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
 //      DELETE1_SIGNAL(out_UPDATE_BTB_CONDITION            ,_param->_nb_inst_branch_update,_param->_size_branch_condition);
 //      DELETE1_SIGNAL(out_UPDATE_BTB_LAST_TAKE            ,_param->_nb_inst_branch_update,1);
 …
         DELETE1_SIGNAL(out_UPDATE_DIR_VAL                  ,_param->_nb_inst_branch_update,1);
         DELETE1_SIGNAL( in_UPDATE_DIR_ACK                  ,_param->_nb_inst_branch_update,1);
 //      DELETE1_SIGNAL(out_UPDATE_DIR_ADDRESS              ,_param->_nb_inst_branch_update,_param->_size_address);
+//      DELETE1_SIGNAL(out_UPDATE_DIR_ADDRESS              ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
 //      DELETE1_SIGNAL(out_UPDATE_DIR_HISTORY              ,_param->_nb_inst_branch_update,_param->_size_history);
 //      DELETE1_SIGNAL(out_UPDATE_DIR_DIRECTION            ,_param->_nb_inst_branch_update,1);
 …
 //      DELETE1_SIGNAL(out_UPDATE_RAS_CONTEXT_ID           ,_param->_nb_inst_branch_update,_param->_size_context_id);
 //      DELETE1_SIGNAL(out_UPDATE_RAS_PUSH                 ,_param->_nb_inst_branch_update,1);
 //      DELETE1_SIGNAL(out_UPDATE_RAS_ADDRESS              ,_param->_nb_inst_branch_update,_param->_size_address);
+//      DELETE1_SIGNAL(out_UPDATE_RAS_ADDRESS              ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
 //      DELETE1_SIGNAL(out_UPDATE_RAS_INDEX                ,_param->_nb_inst_branch_update,_param->_size_ras_index);
 //      DELETE1_SIGNAL(out_UPDATE_RAS_MISS_PREDICTION      ,_param->_nb_inst_branch_update,1);
 …
 //      DELETE1_SIGNAL( in_UPDATE_UPT_DIRECTION_GOOD       ,_param->_nb_inst_branch_update,1);
         DELETE1_SIGNAL( in_UPDATE_UPT_BTB_VAL              ,_param->_nb_inst_branch_update,1);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,_param->_nb_inst_branch_update,_param->_size_address);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,_param->_nb_inst_branch_update,_param->_size_address);
+//      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_SRC      ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
+//      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_ADDRESS_DEST     ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_BTB_CONDITION        ,_param->_nb_inst_branch_update,_param->_size_branch_condition);
         DELETE1_SIGNAL( in_UPDATE_UPT_DIR_VAL              ,_param->_nb_inst_branch_update,1);
 …
         DELETE1_SIGNAL( in_UPDATE_UPT_RAS_VAL              ,_param->_nb_inst_branch_update,1);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_PUSH             ,_param->_nb_inst_branch_update,1);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_ADDRESS          ,_param->_nb_inst_branch_update,_param->_size_address);
+//      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_ADDRESS          ,_param->_nb_inst_branch_update,_param->_size_instruction_address);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_INDEX            ,_param->_nb_inst_branch_update,_param->_size_ras_index);
 //      DELETE1_SIGNAL( in_UPDATE_UPT_RAS_PREDICTION_IFETCH,_param->_nb_inst_branch_update,1);
         // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         DELETE1_SIGNAL( in_DEPTH_UPT_NB_BRANCH,_param->_nb_context,_param->_size_depth[alloc_signal_it1]+1);
         DELETE1_SIGNAL( in_DEPTH_UPT_TAIL     ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]);
         DELETE1_SIGNAL(out_DEPTH_NB_BRANCH    ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]+1);
         DELETE1_SIGNAL(out_DEPTH_TAIL         ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]);
+//      // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//      DELETE1_SIGNAL( in_DEPTH_UPT_NB_BRANCH,_param->_nb_context,_param->_size_depth+1);
+//      DELETE1_SIGNAL( in_DEPTH_UPT_TAIL     ,_param->_nb_context,_param->_size_depth);
+//      DELETE1_SIGNAL(out_DEPTH_NB_BRANCH    ,_param->_nb_context,_param->_size_depth+1);
+//      DELETE1_SIGNAL(out_DEPTH_TAIL         ,_param->_nb_context,_param->_size_depth);
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_genMealy_decod.cpp

-              r82
+              r88
   void Prediction_unit_Glue::genMealy_decod (void)
+  {
+    log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
+    log_begin(Prediction_unit_Glue,FUNCTION);
+    log_function(Prediction_unit_Glue,FUNCTION,_name.c_str());
+    // Init
     uint32_t   decod_unit = reg_DECOD_PRIORITY;
     log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * decod_unit : %d",decod_unit);
 …
       if ((port>=_param->_nb_inst_branch_decod) or
           (PORT_READ(in_DECOD_VAL [decod_unit][i]) == 0))
+        {
+        {
           log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * DECOD[%d][%d] : not valid",decod_unit,i);
           ack [i] = false;
 …
       else
+        {
+          Tcontext_t          context               = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [decod_unit][i]):0;
+          Tbranch_state_t     branch_state          = PORT_READ(in_DECOD_BRANCH_STATE          [decod_unit][i]);
+          Tcontrol_t          match_inst_ifetch_ptr = PORT_READ(in_DECOD_MATCH_INST_IFETCH_PTR [decod_unit][i]);
+          Tprediction_ptr_t   depth   = (_param->_have_port_max_depth)?PORT_READ(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]):0;
+          Tcontrol_t          use_btb = false;
+          Tcontrol_t          use_ras = false;
+          Tcontrol_t          use_upt = true ;
+          Tcontrol_t          miss_ifetch    = ( (branch_state == BRANCH_STATE_NONE) or // branch not detected
+                                                 ((branch_state != BRANCH_STATE_NONE) and (match_inst_ifetch_ptr == 0))); // branch detected, but it's not the good
+          Tcontrol_t          miss_decod;
+          Tcontext_t        context               = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [decod_unit][i]):0;
+          Tbranch_state_t   branch_state          = PORT_READ(in_DECOD_BRANCH_STATE          [decod_unit][i]);
+          Tcontrol_t        match_inst_ifetch_ptr = PORT_READ(in_DECOD_MATCH_INST_IFETCH_PTR [decod_unit][i]);
+          Tprediction_ptr_t depth                 = (_param->_have_port_depth)?PORT_READ(in_DECOD_BRANCH_UPDATE_PREDICTION_ID [decod_unit][i]):0;
+          Tcontrol_t        use_btb               = false;
+          Tcontrol_t        use_ras               = false;
+          Tcontrol_t        use_upt               = true ; // always update upt.
+          // Ifetch stage made an miss if :
+          //   * branch is previously predict, but it's not the good
+          Tcontrol_t        miss_ifetch           = ((branch_state != BRANCH_STATE_NONE) and (match_inst_ifetch_ptr == 0));
+          // Decod stage made an miss if :
+          //   * branch was not detected
+          Tcontrol_t        miss_decod            = (branch_state == BRANCH_STATE_NONE);
           log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * DECOD[%d][%d] :     valid",decod_unit,i);
+          log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * depth   [%d] : %d",i   ,depth);
+          log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * branch_state          : %d",branch_state);
+          log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * match_inst_ifetch_ptr : %d",match_inst_ifetch_ptr);
+          log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * depth                 : [%d] %d",i,depth);
+          log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * miss_ifetch           : %d",miss_ifetch);
+          log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * miss_decod            : %d",miss_decod);
           // Test if ifetch have detecte a branch is the packet
           if (miss_ifetch)
+          if (miss_ifetch or miss_decod)
+            {
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * miss_ifetch");
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * state : %d",branch_state);
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * match : %d",match_inst_ifetch_ptr);
+              Tbranch_condition_t condition             = PORT_READ(in_DECOD_BRANCH_CONDITION            [decod_unit][i]);
+              Tcontrol_t          direction             = PORT_READ(in_DECOD_BRANCH_DIRECTION            [decod_unit][i]);
+              Taddress_t          address_src           = PORT_READ(in_DECOD_ADDRESS_SRC                 [decod_unit][i]);
+              Taddress_t          address_dest          = PORT_READ(in_DECOD_ADDRESS_DEST                [decod_unit][i]);
+              Tbranch_condition_t condition    = PORT_READ(in_DECOD_BRANCH_CONDITION            [decod_unit][i]);
+              Tcontrol_t          direction    = PORT_READ(in_DECOD_BRANCH_DIRECTION            [decod_unit][i]);
+              Taddress_t          address_src  = PORT_READ(in_DECOD_ADDRESS_SRC                 [decod_unit][i]);
+              Taddress_t          address_dest = PORT_READ(in_DECOD_ADDRESS_DEST                [decod_unit][i]);
               Tcontrol_t          is_accurate;
 …
                 case BRANCH_CONDITION_NONE_WITH_WRITE_STACK             :
+                  {
+                    // Write stack
+                    // l.jal
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * BRANCH_CONDITION_NONE_WITH_WRITE_STACK");
+                    is_accurate = true ;//PORT_READ(in_DECOD_RAS_HIT [port]);
+                    use_ras     = true ;
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],1);
+                    PORT_WRITE(out_DECOD_RAS_ADDRESS_PUSH [port],address_src+2);
+                    break;
+                  }
+                case BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK    :
+                  {
+                    // l.jalr
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK");
+                    is_accurate = false; // address unknow : in a register
+                    use_ras     = true;
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],1);
+                    PORT_WRITE(out_DECOD_RAS_ADDRESS_PUSH [port],address_src+2);
+                    break;
+                  }
+                case BRANCH_CONDITION_READ_STACK                        :
+                  {
+                    // l.jr with rb=r9
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * BRANCH_CONDITION_READ_STACK");
                     is_accurate = PORT_READ(in_DECOD_RAS_HIT [port]);
-                    miss_decod  = false;
                     use_ras     = true;
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],1);
+                    PORT_WRITE(out_DECOD_RAS_ADDRESS_PUSH [port],address_dest);
+                    break;
+                  }
+                case BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK    :
+                  {
+                    // Write stack
+                    is_accurate = false;
+                    miss_decod  = false;
+                    use_ras     = true;
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],1);
+                    PORT_WRITE(out_DECOD_RAS_ADDRESS_PUSH [port],address_dest);
+                    break;
+                  }
+                case BRANCH_CONDITION_READ_STACK                        :
+                  {
+                    // Read stack
+                    is_accurate = PORT_READ(in_DECOD_RAS_HIT [port]);
+                    miss_decod  = false;
+                    use_ras     = true;
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],0);
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],0); // POP
                     address_dest = PORT_READ(in_DECOD_RAS_ADDRESS_POP [port]);
 …
                 case BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK :
+                  {
+                    // l.jr with rb!=r9
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK");
                     //   * READ_REGISTER_WITHOUT_WRITE_STACK : Take but destination is unknow - don't continue
+                    is_accurate = PORT_READ(in_DECOD_RAS_HIT [port]);
+                    miss_decod  = true;
+                    is_accurate = false; // address unknow : in a register
                     break;
 …
                 case BRANCH_CONDITION_FLAG_SET                          :
+                  {
                     // No access at the flag
+                    // l.bf, l.bnf
                     //   * FLAG                              : static direction and destination is know
+                    is_accurate = PORT_READ(in_DECOD_RAS_HIT [port]);
+                    miss_decod  = false;
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * BRANCH_CONDITION_FLAG");
+                    is_accurate = true; // address dest is know
                     break;
 …
                 case BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK          :
+                  {
+                    // No access at the flag
+                    //   * NONE_WITHOUT_WRITE_STACK          : take and destination is know
+                    is_accurate = false;
+                    miss_decod  = false;
+                    use_ras     = true;
+                    PORT_WRITE(out_DECOD_RAS_PUSH         [port],1);
+                    PORT_WRITE(out_DECOD_RAS_ADDRESS_PUSH [port],address_dest);
+                    break;
+                  }
+                    // l.j
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK");
+                    is_accurate = true;
+                    break;
+                  }
+                }
 …
               if (use_upt)
+                {
+                  PORT_WRITE(out_DECOD_UPT_BTB_ADDRESS_SRC      [port],address_src);
+                  PORT_WRITE(out_DECOD_UPT_BTB_ADDRESS_DEST     [port],address_dest);
+                  PORT_WRITE(out_DECOD_UPT_BTB_CONDITION        [port],condition);
+                  PORT_WRITE(out_DECOD_UPT_BTB_LAST_TAKE        [port],direction);
+                  PORT_WRITE(out_DECOD_UPT_RAS_ADDRESS          [port],PORT_READ(in_DECOD_RAS_ADDRESS_POP [port]));
+                  PORT_WRITE(out_DECOD_UPT_BTB_ADDRESS_SRC [port],address_src);
+                  PORT_WRITE(out_DECOD_UPT_BTB_ADDRESS_DEST[port],address_dest);
+                  PORT_WRITE(out_DECOD_UPT_BTB_CONDITION   [port],condition);
+                  PORT_WRITE(out_DECOD_UPT_BTB_LAST_TAKE   [port],direction);
+                  PORT_WRITE(out_DECOD_UPT_RAS_ADDRESS     [port],PORT_READ(in_DECOD_RAS_ADDRESS_POP [port]));
+                  PORT_WRITE(out_DECOD_UPT_IS_ACCURATE     [port],is_accurate);
+                }
+            }
+          else
+            {
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * hit");
+              miss_decod = false;
+              // Hit speculation
+            }
+//        else
+//          {
+//               log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * hit");
+//            miss_decod = false;
+//            // Hit speculation
+//          }
           // in all case
           log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * use_btb : %d",use_btb);
 …
           PORT_WRITE(out_DECOD_UPT_MISS_IFETCH          [port],miss_ifetch);
           PORT_WRITE(out_DECOD_UPT_MISS_DECOD           [port],miss_decod );
           if (_param->_have_port_max_depth)
+          if (_param->_have_port_depth)
           PORT_WRITE(out_DECOD_UPT_UPDATE_PREDICTION_ID [port],depth);
 …
+        }
+    // Write output
     for (uint32_t i=0; i<_param->_nb_inst_branch_decod; i++)
+      {
 …
           PORT_WRITE(out_DECOD_ACK [i][j], ack[j]);
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
+    log_end(Prediction_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_genMealy_predict.cpp

-              r82
+              r88
   void Prediction_unit_Glue::genMealy_predict (void)
+  {
+    log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
+    log_begin(Prediction_unit_Glue,FUNCTION);
+    log_function(Prediction_unit_Glue,FUNCTION,_name.c_str());
     Tcontrol_t ack [_param->_nb_context];
     for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
         ack [i] = 0;
         if (_param->_have_port_depth[i])
+          {
             PORT_WRITE(out_DEPTH_TAIL      [i],PORT_READ(in_DEPTH_UPT_TAIL      [i]));
+          }
             PORT_WRITE(out_DEPTH_NB_BRANCH [i],PORT_READ(in_DEPTH_UPT_NB_BRANCH [i]));
+        ack [i] = 0;
+//      if (_param->_have_port_depth)
+//        {
+//      PORT_WRITE(out_DEPTH_TAIL      [i],PORT_READ(in_DEPTH_UPT_TAIL      [i]));
+//        }
+//      PORT_WRITE(out_DEPTH_NB_BRANCH [i],PORT_READ(in_DEPTH_UPT_NB_BRANCH [i]));
+      }
     for (uint32_t i=0; i<_param->_nb_inst_branch_predict; i++)
+      {
         log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"PREDICT [%d]",i);
         Tcontrol_t btb_val;
         Tcontrol_t dir_val;
         Tcontrol_t ras_val;
         Tcontrol_t upt_val;
         Tcontext_t context = (reg_PREDICT_PRIORITY+i)%_param->_nb_context;
         log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * context    : %d",context);
         ack [context] = 1;
         if (PORT_READ(in_PREDICT_VAL[context]) == 0)
+          {
             log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * not valid ...");
             btb_val = false;
             dir_val = false;
             ras_val = false;
             upt_val = false;
+          }
         else
+          {
             log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * valid ...");
             Taddress_t          pc_previous           = PORT_READ(in_PREDICT_PC_PREVIOUS           [context]);
             Taddress_t          pc_current            = PORT_READ(in_PREDICT_PC_CURRENT            [context]);
             Tcontrol_t          pc_current_is_ds_take = PORT_READ(in_PREDICT_PC_CURRENT_IS_DS_TAKE [context]);
             Taddress_t          pc_next                     ;
             Tcontrol_t          pc_next_is_ds_take          ;
             Tbranch_state_t     branch_state                ;
             Tprediction_ptr_t   branch_update_prediction_id ;
             Tinst_ifetch_ptr_t  inst_ifetch_ptr             ;
             // STEP (1) - Compute the address source
             Taddress_t          address     = (pc_current_is_ds_take)?pc_previous:pc_current;
             Taddress_t          address_lsb = pc_current%_param->_nb_instruction [context]; //if pc_current_is_ds_take, then pc_current%_param->_nb_instruction [context] == 0
             Taddress_t          address_msb;
             log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * address    : 0x%x",address);
             // STEP (2) - Test if branch (access at branch_target_buffer)
             btb_val = true;
             ack [context] &= PORT_READ(in_PREDICT_BTB_ACK [i]);
             if (_param->_have_port_context_id)
             PORT_WRITE(out_PREDICT_BTB_CONTEXT_ID [i],context);
             PORT_WRITE(out_PREDICT_BTB_ADDRESS    [i],address);
             // special case :
             //  if pc_current_is_ds, then pc_previous have branch, also hit must be set.
             //  else : a another branch have eject this branch : can't accurate
             Tcontrol_t          hit         = PORT_READ(in_PREDICT_BTB_HIT[i]);
             Tcontrol_t          is_accurate = PORT_READ(in_PREDICT_BTB_IS_ACCURATE  [i]) and not (pc_current_is_ds_take and not hit);
             // STEP (3) : Test if have branch in the packet
             if (hit == 1)
+              {
                 // STEP (3a) : branch - test condition
                 bool                use_dir      = false;
                 bool                use_ras      = false;
                 bool                use_upt      = false;
                 Tbranch_condition_t cond         = PORT_READ(in_PREDICT_BTB_CONDITION    [i]);
                 Taddress_t          address_src  = PORT_READ(in_PREDICT_BTB_ADDRESS_SRC  [i]);
                 Taddress_t          address_dest = PORT_READ(in_PREDICT_BTB_ADDRESS_DEST [i]);
                 Tcontrol_t          push;
                 Tcontrol_t          direction;
                 switch (cond)
+                  {
                   case BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK          : // l.j
+                    {
                       // use none unit (dir, upt and ras)
                       direction    = true;
                       pc_next      = address_dest;
                       branch_state = BRANCH_STATE_NSPEC_TAKE;
                       break;
+                    }
                   case BRANCH_CONDITION_NONE_WITH_WRITE_STACK             : // l.jal
+                    {
                       use_upt      = true;
                       use_ras      = true;
                       push         = true;
                       direction    = true;
                       pc_next      = address_dest;
                       branch_state = BRANCH_STATE_NSPEC_TAKE;
                       break;
+                    }
                   case BRANCH_CONDITION_FLAG_UNSET                        : // l.bnf
                   case BRANCH_CONDITION_FLAG_SET                          : // l.bf
+                    {
                       use_upt      = true;
                       use_dir      = true;
                       // Test direction
                       direction = PORT_READ(in_PREDICT_DIR_DIRECTION [i]); // Direction is not the "flag predict" ... also flag_unset and flag_set is the same
                       if (direction = 1)
+                        {
                           branch_state = BRANCH_STATE_SPEC_TAKE;
                           pc_next      = address_dest;
+                        }
                       else
+                        {
                           branch_state = BRANCH_STATE_SPEC_NTAKE;
                           pc_next      = address_src+2; // +1 = delay slot
+                        }
                       break;
+                    }
                   case BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK : // l.jr (rb!=9)
+                    {
                       use_upt      = true;
                       use_ras      = true;
                       push         = true;
                       direction    = true;
                       pc_next      = address_dest;
                       branch_state = BRANCH_STATE_SPEC_TAKE;
                       break;
+                    }
                   case BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK    : // l.jalr
+                    {
                       use_upt      = true;
                       use_ras      = true;
                       push         = true;
                       direction    = true;
                       pc_next      = address_dest;
                       branch_state = BRANCH_STATE_NSPEC_TAKE;
                       break;
+                    }
                   case BRANCH_CONDITION_READ_STACK                        : // l.jr (rb==9)
+                    {
                       use_upt      = true;
                       use_ras      = true;
                       push         = false;
                       direction    = true;
                       pc_next      = PORT_READ(in_PREDICT_RAS_ADDRESS_POP  [i]);
                       branch_state = BRANCH_STATE_SPEC_TAKE;
                       break;
+                    }
                   default :
+                    {
                       ERRORMORPHEO(FUNCTION,"Unknow Condition");
                       break;
+                    }
+                  }
                 if (use_dir)
+                  {
                     ack[context] &= PORT_READ(in_PREDICT_DIR_ACK [i]);
                     PORT_WRITE(out_PREDICT_DIR_ADDRESS_SRC [i], address_src);
                     PORT_WRITE(out_PREDICT_DIR_STATIC      [i], address_dest<address_src); // if destination is previous : the static direction is take
 //                  PORT_WRITE(out_PREDICT_DIR_LAST_TAKE   [i], PORT_READ(in_PREDICT_BTB_LAST_TAKE [i]));
+                  }
                 if (use_ras)
+                  {
                     ack[context] &= PORT_READ(in_PREDICT_RAS_ACK [i]);
                     if (_param->_have_port_context_id)
                     PORT_WRITE(out_PREDICT_RAS_CONTEXT_ID   [i], context);
                     PORT_WRITE(out_PREDICT_RAS_PUSH         [i], push);
                     PORT_WRITE(out_PREDICT_RAS_ADDRESS_PUSH [i], address_src+2);
                     is_accurate &= PORT_READ(in_PREDICT_RAS_HIT [i]); // if miss - prediction is not accurate
+                  }
                 if (use_upt)
+                  {
                     ack[context] &= PORT_READ(in_PREDICT_UPT_ACK [i]);
                     PORT_WRITE(out_PREDICT_UPT_CONTEXT_ID       [i],context);
                     PORT_WRITE(out_PREDICT_UPT_BTB_ADDRESS_SRC  [i],address_src);
                     PORT_WRITE(out_PREDICT_UPT_BTB_ADDRESS_DEST [i],address_dest);
                     PORT_WRITE(out_PREDICT_UPT_BTB_CONDITION    [i],cond);
                     PORT_WRITE(out_PREDICT_UPT_BTB_LAST_TAKE    [i],direction);
                     PORT_WRITE(out_PREDICT_UPT_BTB_IS_ACCURATE  [i],is_accurate);
 //                  PORT_WRITE(out_PREDICT_UPT_DIR_HISTORY      [i],PORT_READ(in_PREDICT_DIR_HISTORY      [i]));
                     PORT_WRITE(out_PREDICT_UPT_RAS_ADDRESS      [i],PORT_READ(in_PREDICT_RAS_ADDRESS_POP  [i]));
 //                  PORT_WRITE(out_PREDICT_UPT_RAS_INDEX        [i],PORT_READ(in_PREDICT_RAS_INDEX        [i]));
+                  }
                 // ack = 1 if :
                 //   *             btb_ack
                 //   * use_dir and dir_ack
                 //   * use_ras and ras_ack
                 //   * use_upt and upt_ack
 //              ack [context] = (PORT_READ(in_PREDICT_BTB_ACK [i]) and
 //                               (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i])) and
 //                               (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i])) and
 //                               (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i])));
                 dir_val = (use_dir and
                            PORT_READ(in_PREDICT_BTB_ACK [i]) and
                            (not use_ras or (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i]))) and
                            (not use_upt or (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i]))));
                 ras_val = (use_ras and
                            PORT_READ(in_PREDICT_BTB_ACK [i]) and
                            (not use_dir or (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i]))) and
                            (not use_upt or (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i]))));
                 upt_val = (use_upt and
                            PORT_READ(in_PREDICT_BTB_ACK [i]) and
                            (not use_dir or (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i]))) and
                            (not use_ras or (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i]))));
 //              pc_next      - is previously computed
 //              branch_state - is previously computed
                 Taddress_t address_src_lsb  = address_src%_param->_nb_instruction [context];
                 log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address_src     : 0x%x",address_src);
                 log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address_src_lsb : %d",address_src_lsb);
                 if (address_src_lsb == (_param->_nb_instruction [context]-1))
+                  {
                     // branch is in the last slot of the packet
                     log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * branch is in the last slot of the packet");
                     address_msb        = _param->_nb_instruction [context]; // == (address_src_lsb+1)
                     pc_next_is_ds_take = 1;
+                  }
                 else
+                  {
                     // branch is in the last slot of the packet
                     address_msb        = (address_src_lsb+2); // +1 == delayed slot
                     pc_next_is_ds_take = 0;
+                  }
                 log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address_msb     : %d",address_msb);
                 inst_ifetch_ptr             = address_src_lsb;
                 branch_update_prediction_id = (_param->_have_port_depth[context])?((PORT_READ(in_DEPTH_UPT_TAIL[context])+PORT_READ(in_DEPTH_UPT_NB_BRANCH [context]))%_param->_size_depth[context]):0;
+              }
             else
+              {
                 // STEP (3b) : Sequential order : compute next paquet
                 log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * BTB miss : sequential order");
                 pc_next                     = address-address_lsb+_param->_nb_instruction [context]; // sequencial
                 pc_next_is_ds_take          = 0; // no branch, also no delay slot
                 inst_ifetch_ptr             = 0;
                 branch_state                = BRANCH_STATE_NONE;
                 branch_update_prediction_id = 0;
                 address_msb = _param->_nb_instruction [context];
+              }
               PORT_WRITE(out_PREDICT_PC_NEXT                     [context]   , pc_next                    );
               PORT_WRITE(out_PREDICT_PC_NEXT_IS_DS_TAKE          [context]   , pc_next_is_ds_take         );
               log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * instruction enable :");
               log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * nb_inst : %d",_param->_nb_instruction [context]);
               log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * [0:%d[ = 0",address_lsb);
               log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * [%d:%d[ = 1",address_lsb,((pc_current_is_ds_take)?1:address_msb));
               log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * [%d:%d[ = 0",((pc_current_is_ds_take)?1:address_msb),_param->_nb_instruction [context]);
               for (uint32_t j=0; j<address_lsb; j++)
               PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 0); // Before the address : not valid
               for (uint32_t j=address_lsb; j<((pc_current_is_ds_take)?1:address_msb); j++)
               PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 1); // Vald packet
               for (uint32_t j=((pc_current_is_ds_take)?1:address_msb); j<_param->_nb_instruction [context]; j++)
               PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 0); // After last address (branch) : not valid
               if (_param->_have_port_inst_ifetch_ptr[context])
               PORT_WRITE(out_PREDICT_INST_IFETCH_PTR             [context]   , inst_ifetch_ptr            );
               PORT_WRITE(out_PREDICT_BRANCH_STATE                [context]   , branch_state               );
               if (_param->_have_port_depth[context])
               PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [context]   , branch_update_prediction_id);
+          }
         // Write output
         PORT_WRITE(out_PREDICT_BTB_VAL [i], btb_val);
         PORT_WRITE(out_PREDICT_DIR_VAL [i], dir_val);
         PORT_WRITE(out_PREDICT_RAS_VAL [i], ras_val);
         PORT_WRITE(out_PREDICT_UPT_VAL [i], upt_val);
+        log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"  * PREDICT [%d]",i);
+        Tcontrol_t btb_val;
+        Tcontrol_t dir_val;
+        Tcontrol_t ras_val;
+        Tcontrol_t upt_val;
+        Tcontext_t context = (reg_PREDICT_PRIORITY+i)%_param->_nb_context;
+        log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * context    : %d",context);
+        ack [context] = 1;
+        if (PORT_READ(in_PREDICT_VAL[context]) == 0)
+          {
+            log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * not valid ...");
+            btb_val = false;
+            dir_val = false;
+            ras_val = false;
+            upt_val = false;
+          }
+        else
+          {
+            log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * valid ...");
+            Taddress_t          pc_previous           = PORT_READ(in_PREDICT_PC_PREVIOUS           [context]);
+            Taddress_t          pc_current            = PORT_READ(in_PREDICT_PC_CURRENT            [context]);
+            Tcontrol_t          pc_current_is_ds_take = PORT_READ(in_PREDICT_PC_CURRENT_IS_DS_TAKE [context]);
+            Taddress_t          pc_next                     ;
+            Tcontrol_t          pc_next_is_ds_take          ;
+            Tbranch_state_t     branch_state                ;
+//          Tprediction_ptr_t   branch_update_prediction_id ;
+            Tinst_ifetch_ptr_t  inst_ifetch_ptr             ;
+            // STEP (1) - Compute the address source
+            Taddress_t          address     = (pc_current_is_ds_take)?pc_previous:pc_current;
+            Taddress_t          address_lsb = pc_current%_param->_nb_instruction [context]; //if pc_current_is_ds_take, then pc_current%_param->_nb_instruction [context] == 0
+            Taddress_t          address_msb;
+            log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * address    : 0x%x",address);
+            // STEP (2) - Test if branch (access at branch_target_buffer)
+            btb_val = true;
+            ack [context] &= PORT_READ(in_PREDICT_BTB_ACK [i]);
+            if (_param->_have_port_context_id)
+            PORT_WRITE(out_PREDICT_BTB_CONTEXT_ID [i],context);
+            PORT_WRITE(out_PREDICT_BTB_ADDRESS    [i],address);
+            // special case :
+            //  if pc_current_is_ds, then pc_previous have branch, also hit must be set.
+            //  else : a another branch have eject this branch : can't accurate
+            Tcontrol_t          hit         = PORT_READ(in_PREDICT_BTB_HIT[i]);
+            Tcontrol_t          is_accurate = PORT_READ(in_PREDICT_BTB_IS_ACCURATE  [i]) and not (pc_current_is_ds_take and not hit);
+            // STEP (3) : Test if have branch in the packet
+            if (hit == 1)
+              {
+                // STEP (3a) : branch - test condition
+                bool                use_dir      = false;
+                bool                use_ras      = false;
+                bool                use_upt      = false;
+                Tbranch_condition_t cond         = PORT_READ(in_PREDICT_BTB_CONDITION    [i]);
+                Taddress_t          address_src  = PORT_READ(in_PREDICT_BTB_ADDRESS_SRC  [i]);
+                Taddress_t          address_dest = PORT_READ(in_PREDICT_BTB_ADDRESS_DEST [i]);
+                Tcontrol_t          push;
+                Tcontrol_t          direction;
+                switch (cond)
+                  {
+                  case BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK          : // l.j
+                    {
+                      // use none unit (dir, upt and ras)
+                      direction    = true;
+                      pc_next      = address_dest;
+                      branch_state = BRANCH_STATE_NSPEC_TAKE;
+                      break;
+                    }
+                  case BRANCH_CONDITION_NONE_WITH_WRITE_STACK             : // l.jal
+                    {
+                      use_upt      = true;
+                      use_ras      = true;
+                      push         = true;
+                      direction    = true;
+                      pc_next      = address_dest;
+                      branch_state = BRANCH_STATE_NSPEC_TAKE;
+                      break;
+                    }
+                  case BRANCH_CONDITION_FLAG_UNSET                        : // l.bnf
+                  case BRANCH_CONDITION_FLAG_SET                          : // l.bf
+                    {
+                      use_upt      = true;
+                      use_dir      = true;
+                      // Test direction
+                      direction = PORT_READ(in_PREDICT_DIR_DIRECTION [i]); // Direction is not the "flag predict" ... also flag_unset and flag_set is the same
+                      if (direction = 1)
+                        {
+                          branch_state = BRANCH_STATE_SPEC_TAKE;
+                          pc_next      = address_dest;
+                        }
+                      else
+                        {
+                          branch_state = BRANCH_STATE_SPEC_NTAKE;
+                          pc_next      = address_src+2; // +1 = delay slot
+                        }
+                      break;
+                    }
+                  case BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK : // l.jr (rb!=9)
+                    {
+                      use_upt      = true;
+                      use_ras      = true;
+                      push         = true;
+                      direction    = true;
+                      pc_next      = address_dest;
+                      branch_state = BRANCH_STATE_SPEC_TAKE;
+                      break;
+                    }
+                  case BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK    : // l.jalr
+                    {
+                      use_upt      = true;
+                      use_ras      = true;
+                      push         = true;
+                      direction    = true;
+                      pc_next      = address_dest;
+                      branch_state = BRANCH_STATE_NSPEC_TAKE;
+                      break;
+                    }
+                  case BRANCH_CONDITION_READ_STACK                        : // l.jr (rb==9)
+                    {
+                      use_upt      = true;
+                      use_ras      = true;
+                      push         = false;
+                      direction    = true;
+                      pc_next      = PORT_READ(in_PREDICT_RAS_ADDRESS_POP  [i]);
+                      branch_state = BRANCH_STATE_SPEC_TAKE;
+                      break;
+                    }
+                  default :
+                    {
+                      ERRORMORPHEO(FUNCTION,"Unknow Condition");
+                      break;
+                    }
+                  }
+                if (use_dir)
+                  {
+                    ack[context] &= PORT_READ(in_PREDICT_DIR_ACK [i]);
+                    PORT_WRITE(out_PREDICT_DIR_ADDRESS_SRC [i], address_src);
+                    PORT_WRITE(out_PREDICT_DIR_STATIC      [i], address_dest<address_src); // if destination is previous : the static direction is take
+//                  PORT_WRITE(out_PREDICT_DIR_LAST_TAKE   [i], PORT_READ(in_PREDICT_BTB_LAST_TAKE [i]));
+                  }
+                if (use_ras)
+                  {
+                    ack[context] &= PORT_READ(in_PREDICT_RAS_ACK [i]);
+                    if (_param->_have_port_context_id)
+                    PORT_WRITE(out_PREDICT_RAS_CONTEXT_ID   [i], context);
+                    PORT_WRITE(out_PREDICT_RAS_PUSH         [i], push);
+                    PORT_WRITE(out_PREDICT_RAS_ADDRESS_PUSH [i], address_src+2);
+                    is_accurate &= PORT_READ(in_PREDICT_RAS_HIT [i]); // if miss - prediction is not accurate
+                  }
+                if (use_upt)
+                  {
+                    ack[context] &= PORT_READ(in_PREDICT_UPT_ACK [i]);
+                    PORT_WRITE(out_PREDICT_UPT_CONTEXT_ID       [i],context);
+                    PORT_WRITE(out_PREDICT_UPT_BTB_ADDRESS_SRC  [i],address_src);
+                    PORT_WRITE(out_PREDICT_UPT_BTB_ADDRESS_DEST [i],address_dest);
+                    PORT_WRITE(out_PREDICT_UPT_BTB_CONDITION    [i],cond);
+                    PORT_WRITE(out_PREDICT_UPT_BTB_LAST_TAKE    [i],direction);
+                    PORT_WRITE(out_PREDICT_UPT_BTB_IS_ACCURATE  [i],is_accurate);
+//                  PORT_WRITE(out_PREDICT_UPT_DIR_HISTORY      [i],PORT_READ(in_PREDICT_DIR_HISTORY      [i]));
+                    PORT_WRITE(out_PREDICT_UPT_RAS_ADDRESS      [i],PORT_READ(in_PREDICT_RAS_ADDRESS_POP  [i]));
+//                  PORT_WRITE(out_PREDICT_UPT_RAS_INDEX        [i],PORT_READ(in_PREDICT_RAS_INDEX        [i]));
+                  }
+                // ack = 1 if :
+                //   *             btb_ack
+                //   * use_dir and dir_ack
+                //   * use_ras and ras_ack
+                //   * use_upt and upt_ack
+//              ack [context] = (PORT_READ(in_PREDICT_BTB_ACK [i]) and
+//                               (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i])) and
+//                               (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i])) and
+//                               (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i])));
+                dir_val = (use_dir and
+                           PORT_READ(in_PREDICT_BTB_ACK [i]) and
+                           (not use_ras or (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i]))) and
+                           (not use_upt or (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i]))));
+                ras_val = (use_ras and
+                           PORT_READ(in_PREDICT_BTB_ACK [i]) and
+                           (not use_dir or (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i]))) and
+                           (not use_upt or (use_upt and PORT_READ(in_PREDICT_UPT_ACK [i]))));
+                upt_val = (use_upt and
+                           PORT_READ(in_PREDICT_BTB_ACK [i]) and
+                           (not use_dir or (use_dir and PORT_READ(in_PREDICT_DIR_ACK [i]))) and
+                           (not use_ras or (use_ras and PORT_READ(in_PREDICT_RAS_ACK [i]))));
+//              pc_next      - is previously computed
+//              branch_state - is previously computed
+                Taddress_t address_src_lsb  = address_src%_param->_nb_instruction [context];
+                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * address_src     : 0x%x",address_src);
+                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * address_src_lsb : %d",address_src_lsb);
+                if (address_src_lsb == (_param->_nb_instruction [context]-1))
+                  {
+                    // branch is in the last slot of the packet
+                    log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * branch is in the last slot of the packet");
+                    address_msb        = _param->_nb_instruction [context]; // == (address_src_lsb+1)
+                    pc_next_is_ds_take = 1;
+                  }
+                else
+                  {
+                    // branch is in the last slot of the packet
+                    address_msb        = (address_src_lsb+2); // +1 == delayed slot
+                    pc_next_is_ds_take = 0;
+                  }
+                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * address_msb     : %d",address_msb);
+                inst_ifetch_ptr             = address_src_lsb;
+//              branch_update_prediction_id = (_param->_have_port_depth)?((PORT_READ(in_DEPTH_UPT_TAIL[context])+PORT_READ(in_DEPTH_UPT_NB_BRANCH [context]))%_param->_array_size_depth[context]):0;
+              }
+            else
+              {
+                // STEP (3b) : Sequential order : compute next paquet
+                log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * BTB miss : sequential order");
+                pc_next                     = address-address_lsb+_param->_nb_instruction [context]; // sequencial
+                pc_next_is_ds_take          = 0; // no branch, also no delay slot
+                inst_ifetch_ptr             = 0;
+                branch_state                = BRANCH_STATE_NONE;
+//              branch_update_prediction_id = 0;
+                address_msb = _param->_nb_instruction [context];
+              }
+              PORT_WRITE(out_PREDICT_PC_NEXT                     [context]   , pc_next                    );
+              PORT_WRITE(out_PREDICT_PC_NEXT_IS_DS_TAKE          [context]   , pc_next_is_ds_take         );
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"    * instruction enable :");
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * nb_inst : %d",_param->_nb_instruction [context]);
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * [0:%d[ = 0",address_lsb);
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * [%d:%d[ = 1",address_lsb,((pc_current_is_ds_take)?1:address_msb));
+              log_printf(TRACE,Prediction_unit_Glue,FUNCTION,"      * [%d:%d[ = 0",((pc_current_is_ds_take)?1:address_msb),_param->_nb_instruction [context]);
+              for (uint32_t j=0; j<address_lsb; j++)
+              PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 0); // Before the address : not valid
+              for (uint32_t j=address_lsb; j<((pc_current_is_ds_take)?1:address_msb); j++)
+              PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 1); // Vald packet
+              for (uint32_t j=((pc_current_is_ds_take)?1:address_msb); j<_param->_nb_instruction [context]; j++)
+              PORT_WRITE(out_PREDICT_INSTRUCTION_ENABLE          [context][j], 0); // After last address (branch) : not valid
+              if (_param->_have_port_inst_ifetch_ptr)
+              PORT_WRITE(out_PREDICT_INST_IFETCH_PTR             [context]   , inst_ifetch_ptr            );
+              PORT_WRITE(out_PREDICT_BRANCH_STATE                [context]   , branch_state               );
+              if (_param->_have_port_depth)
+              PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [context]   , PORT_READ(in_PREDICT_UPT_BRANCH_UPDATE_PREDICTION_ID [i]));
+          }
+        // Write output
+        PORT_WRITE(out_PREDICT_BTB_VAL [i], btb_val);
+        PORT_WRITE(out_PREDICT_DIR_VAL [i], dir_val);
+        PORT_WRITE(out_PREDICT_RAS_VAL [i], ras_val);
+        PORT_WRITE(out_PREDICT_UPT_VAL [i], upt_val);
+      }
 …
       PORT_WRITE(out_PREDICT_ACK[i],ack[i]);
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
+    log_end(Prediction_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_genMealy_update.cpp

-              r82
+              r88
   void Prediction_unit_Glue::genMealy_update (void)
+  {
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
+    log_begin(Prediction_unit_Glue,FUNCTION);
 //     for (uint32_t i=0; i<_param->_nb_inst_branch_update; i++)
 …
 //       }
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
+    log_end(Prediction_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue/src/Prediction_unit_Glue_transition.cpp

-              r82
+              r88
   void Prediction_unit_Glue::transition (void)
+  {
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"Begin");
+    log_begin(Prediction_unit_Glue,FUNCTION);
     if (PORT_READ(in_NRESET) == 0)
 …
 #endif
     log_printf(FUNC,Prediction_unit_Glue,FUNCTION,"End");
+    log_end(Prediction_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/Makefile

r81	r88
24	24	library_clean : Return_Address_Stack_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/config_mono_context.cfg

-              r81
+              r88
        4       *2      # size_queue     [0]
       32      *2      # size_address
        1       +1      # nb_inst_predict
        1       +1      # nb_inst_decod
        1       +1      # nb_inst_update
+       4       *4      # nb_inst_predict
+       4       *4      # nb_inst_decod
+       4       *4      # nb_inst_update

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/config_multi_context.cfg

-              r81
+              r88
        4       *2      # size_queue     [1]
        8       *2      # size_queue     [2]
       16      *2      # size_queue     [3]
+       8       *2      # size_queue     [3]
       32      *2      # size_address
        1       +1      # nb_inst_predict
        1       +1      # nb_inst_decod
        1       +1      # nb_inst_update
+       4       *4      # nb_inst_predict
+       4       *4      # nb_inst_decod
+       4       *4      # nb_inst_update

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_inst_predict ,
          _nb_inst_decod   ,
+         _nb_inst_update  );
+         _nb_inst_update  ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Return_Address_Stack * _Return_Address_Stack = new Return_Address_Stack
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
         in_DECOD_VAL [port1]->write(0);
+      }
+        }
+    }
 …
   delete in_NRESET;
+  delete []  in_PREDICT_VAL          ;
+  delete [] out_PREDICT_ACK          ;
+  delete []  in_PREDICT_CONTEXT_ID   ;
+  delete [] out_PREDICT_HIT          ;
+  delete []  in_PREDICT_PUSH         ;
+  delete []  in_PREDICT_ADDRESS_PUSH ;
+  delete [] out_PREDICT_ADDRESS_POP  ;
+  delete [] out_PREDICT_INDEX        ;
+  delete []  in_DECOD_VAL            ;
+  delete [] out_DECOD_ACK            ;
+  delete []  in_DECOD_PUSH           ;
+  delete []  in_DECOD_CONTEXT_ID     ;
+  delete [] out_DECOD_HIT            ;
+  delete []  in_DECOD_ADDRESS_PUSH   ;
+  delete [] out_DECOD_ADDRESS_POP    ;
+  delete [] out_DECOD_INDEX          ;
+  delete []  in_DECOD_MISS_PREDICTION;
+  delete []  in_UPDATE_VAL           ;
+  delete [] out_UPDATE_ACK           ;
+  delete []  in_UPDATE_CONTEXT_ID    ;
+  delete []  in_UPDATE_PUSH          ;
+  delete []  in_UPDATE_INDEX         ;
+  delete []  in_UPDATE_ADDRESS       ;
+  delete []  in_UPDATE_MISS_PREDICTION;
+  delete []  in_UPDATE_PREDICTION_IFETCH;
+  DELETE1_SC_SIGNAL( in_PREDICT_VAL             ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL(out_PREDICT_ACK             ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL( in_PREDICT_CONTEXT_ID      ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL(out_PREDICT_HIT             ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL( in_PREDICT_PUSH            ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL( in_PREDICT_ADDRESS_PUSH    ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL(out_PREDICT_ADDRESS_POP     ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL(out_PREDICT_INDEX           ,_param->_nb_inst_predict);
+  DELETE1_SC_SIGNAL( in_DECOD_VAL               ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_ACK               ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DECOD_CONTEXT_ID        ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_HIT               ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DECOD_PUSH              ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DECOD_ADDRESS_PUSH      ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_ADDRESS_POP       ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL(out_DECOD_INDEX             ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_DECOD_MISS_PREDICTION   ,_param->_nb_inst_decod);
+  DELETE1_SC_SIGNAL( in_UPDATE_VAL              ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL(out_UPDATE_ACK              ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL( in_UPDATE_CONTEXT_ID       ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL( in_UPDATE_PUSH             ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL( in_UPDATE_ADDRESS          ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL( in_UPDATE_INDEX            ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL( in_UPDATE_MISS_PREDICTION  ,_param->_nb_inst_update);
+  DELETE1_SC_SIGNAL( in_UPDATE_PREDICTION_IFETCH,_param->_nb_inst_update);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/include/Parameters.h

-              r81
+              r88
   public : uint32_t   _nb_context     ;
   public : uint32_t * _size_queue     ;//[nb_context]
   public : uint32_t   _size_address   ;
+//public : uint32_t   _size_address   ;
   public : uint32_t   _nb_inst_predict;
   public : uint32_t   _nb_inst_decod  ;
   public : uint32_t   _nb_inst_update ;
   public : uint32_t   _size_context_id;
+//public : uint32_t   _size_context_id;
   public : uint32_t   _size_index     ;
   public : uint32_t   _have_port_context_id;
+//public : uint32_t   _have_port_context_id;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t   nb_inst_predict,
                         uint32_t   nb_inst_decod  ,
+                        uint32_t   nb_inst_update );
+                        uint32_t   nb_inst_update ,
+                        bool       is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_inst_predict,
                           uint32_t   nb_inst_decod  ,
+                          uint32_t   nb_inst_update )
+                          uint32_t   nb_inst_update ,
+                          bool       is_toplevel
+                          )
+  {
     log_printf(FUNC,Return_Address_Stack,FUNCTION,"Begin");
 …
     _nb_context      = nb_context     ;
     _size_queue      = size_queue     ;
-    _size_address    = size_address   ;
     _nb_inst_predict = nb_inst_predict;
     _nb_inst_decod   = nb_inst_decod  ;
     _nb_inst_update  = nb_inst_update ;
-    _size_context_id = log2(nb_context);
     _size_index      = max<uint32_t>(size_queue,nb_context);
     _have_port_context_id = _size_context_id > 0;
+    test();
+    test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address   ;
+        _size_context_id          = log2(nb_context);
+        _have_port_context_id     = _size_context_id > 0;
+        copy ();
+      }
     log_printf(FUNC,Return_Address_Stack,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Return_Address_Stack::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Return_Address_Stack,FUNCTION,"Begin");
+    log_printf(FUNC,Return_Address_Stack,FUNCTION,"End");
+  };
 }; // end namespace return_address_stack
 }; // end namespace prediction_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Parameters_msg_error.cpp

r81	r88
29	29	for (uint32_t i=0; i<_nb_context; i++)
30	30	if (_size_queue [i] < 2)
31		test.error(~~"context \""+toString(i)+"\" : size_queue must be > 2"~~);
	31	test.error(toString(_("context \"%d\" : size_queue must be >= 2\n"),i));
32	32
33	33	log_printf(FUNC,Return_Address_Stack,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Parameters_print.cpp

r81	r88
28	28	xml.balise_open("return_address_stack");
29	29	xml.singleton_begin("nb_context "); xml.attribut("value",toString(_nb_context )); xml.singleton_end();
30		xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
	30	// xml.singleton_begin("size_address "); xml.attribut("value",toString(_size_address )); xml.singleton_end();
31	31	xml.singleton_begin("nb_inst_predict"); xml.attribut("value",toString(_nb_inst_predict)); xml.singleton_end();
32	32	xml.singleton_begin("nb_inst_decod "); xml.attribut("value",toString(_nb_inst_decod )); xml.singleton_end();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack.cpp

-              r81
+              r88
     log_printf(FUNC,Return_Address_Stack,FUNCTION,"Begin");
+#if DEBUG_Return_Address_Stac == true
+    log_printf(INFO,Return_Address_Stac,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Return_Address_Stack,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Return_Address_Stack,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_allocation.cpp

-              r81
+              r88
 namespace return_address_stack {
 #undef  FUNCTION
 #define FUNCTION "Return_Address_Stack::allocation"
   void Return_Address_Stack::allocation (
 #ifdef STATISTICS
                                morpheo::behavioural::Parameters_Statistics * param_statistics
+                                         morpheo::behavioural::Parameters_Statistics * param_statistics
 #else
                                void
+                                         void
 #endif
+                               )
+                                         )
+  {
     log_printf(FUNC,Return_Address_Stack,FUNCTION,"Begin");
 …
       ALLOC1_SIGNAL_OUT(out_PREDICT_HIT         ,"hit"         ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_PUSH        ,"push"        ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS_PUSH,"address_push",Taddress_t,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_POP ,"address_pop" ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_ADDRESS_PUSH,"address_push",Taddress_t,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_POP ,"address_pop" ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_PREDICT_INDEX       ,"index"       ,Tptr_t    ,_param->_size_index);
+    }
 …
       ALLOC1_SIGNAL_OUT(out_DECOD_HIT            ,"hit"            ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_DECOD_PUSH           ,"push"           ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_PUSH   ,"address_push"   ,Taddress_t,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS_POP    ,"address_pop"    ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_ADDRESS_PUSH   ,"address_push"   ,Taddress_t,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS_POP    ,"address_pop"    ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_DECOD_INDEX          ,"index"          ,Tptr_t    ,_param->_size_index);
       ALLOC1_SIGNAL_IN ( in_DECOD_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
 …
       ALLOC1_INTERFACE("update", IN, SOUTH, "update's interface", _param->_nb_inst_update);
       ALLOC1_VALACK_IN ( in_UPDATE_VAL            ,VAL);
       ALLOC1_VALACK_OUT(out_UPDATE_ACK            ,ACK);
       ALLOC1_SIGNAL_IN ( in_UPDATE_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_UPDATE_PUSH           ,"push"           ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS        ,"address"        ,Taddress_t,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_UPDATE_INDEX          ,"index"          ,Tptr_t    ,_param->_size_index);
       ALLOC1_SIGNAL_IN ( in_UPDATE_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
+      ALLOC1_VALACK_IN ( in_UPDATE_VAL              ,VAL);
+      ALLOC1_VALACK_OUT(out_UPDATE_ACK              ,ACK);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_CONTEXT_ID       ,"context_id"       ,Tcontext_t,_param->_size_context_id);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_PUSH             ,"push"             ,Tcontrol_t,1);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_ADDRESS          ,"address"          ,Taddress_t,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_INDEX            ,"index"            ,Tptr_t    ,_param->_size_index);
+      ALLOC1_SIGNAL_IN ( in_UPDATE_MISS_PREDICTION  ,"miss_prediction"  ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_UPDATE_PREDICTION_IFETCH,"prediction_ifetch",Tcontrol_t,1);
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     internal_DECOD_HIT   = new Tcontrol_t [_param->_nb_inst_decod  ];
     internal_UPDATE_ACK  = new Tcontrol_t [_param->_nb_inst_update ];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_deallocation.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/include/Return_Address_Stack.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
     log_printf(FUNC,Return_Address_Stack,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
         delete    in_NRESET;
+        delete []  in_PREDICT_VAL          ;
+        delete [] out_PREDICT_ACK          ;
+        if (_param->_have_port_context_id)
+        delete []  in_PREDICT_CONTEXT_ID   ;
+        delete [] out_PREDICT_HIT          ;
+        delete []  in_PREDICT_PUSH         ;
+        delete []  in_PREDICT_ADDRESS_PUSH ;
+        delete [] out_PREDICT_ADDRESS_POP  ;
+        delete [] out_PREDICT_INDEX        ;
+        delete []  in_DECOD_VAL            ;
+        delete [] out_DECOD_ACK            ;
+        delete []  in_DECOD_PUSH           ;
+        if (_param->_have_port_context_id)
+        delete []  in_DECOD_CONTEXT_ID     ;
+        delete [] out_DECOD_HIT            ;
+        delete []  in_DECOD_ADDRESS_PUSH   ;
+        delete [] out_DECOD_ADDRESS_POP    ;
+        delete [] out_DECOD_INDEX          ;
+        delete []  in_DECOD_MISS_PREDICTION;
+        delete []  in_UPDATE_VAL           ;
+        delete [] out_UPDATE_ACK           ;
+        if (_param->_have_port_context_id)
+        delete []  in_UPDATE_CONTEXT_ID    ;
+        delete []  in_UPDATE_PUSH          ;
+        delete []  in_UPDATE_INDEX         ;
+        delete []  in_UPDATE_ADDRESS       ;
+        delete []  in_UPDATE_MISS_PREDICTION;
+        delete []  in_UPDATE_PREDICTION_IFETCH;
+        DELETE1_SIGNAL( in_PREDICT_VAL             ,_param->_nb_inst_predict,1);
+        DELETE1_SIGNAL(out_PREDICT_ACK             ,_param->_nb_inst_predict,1);
+        DELETE1_SIGNAL( in_PREDICT_CONTEXT_ID      ,_param->_nb_inst_predict,_param->_size_context_id);
+        DELETE1_SIGNAL(out_PREDICT_HIT             ,_param->_nb_inst_predict,1);
+        DELETE1_SIGNAL( in_PREDICT_PUSH            ,_param->_nb_inst_predict,1);
+        DELETE1_SIGNAL( in_PREDICT_ADDRESS_PUSH    ,_param->_nb_inst_predict,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_PREDICT_ADDRESS_POP     ,_param->_nb_inst_predict,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_PREDICT_INDEX           ,_param->_nb_inst_predict,_param->_size_index);
+        DELETE1_SIGNAL( in_DECOD_VAL               ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL(out_DECOD_ACK               ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL( in_DECOD_CONTEXT_ID        ,_param->_nb_inst_decod,_param->_size_context_id);
+        DELETE1_SIGNAL(out_DECOD_HIT               ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL( in_DECOD_PUSH              ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL( in_DECOD_ADDRESS_PUSH      ,_param->_nb_inst_decod,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_DECOD_ADDRESS_POP       ,_param->_nb_inst_decod,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_DECOD_INDEX             ,_param->_nb_inst_decod,_param->_size_index);
+        DELETE1_SIGNAL( in_DECOD_MISS_PREDICTION   ,_param->_nb_inst_decod,1);
+        DELETE1_SIGNAL( in_UPDATE_VAL              ,_param->_nb_inst_update,1);
+        DELETE1_SIGNAL(out_UPDATE_ACK              ,_param->_nb_inst_update,1);
+        DELETE1_SIGNAL( in_UPDATE_CONTEXT_ID       ,_param->_nb_inst_update,_param->_size_context_id);
+        DELETE1_SIGNAL( in_UPDATE_PUSH             ,_param->_nb_inst_update,1);
+        DELETE1_SIGNAL( in_UPDATE_ADDRESS          ,_param->_nb_inst_update,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_UPDATE_INDEX            ,_param->_nb_inst_update,_param->_size_index);
+        DELETE1_SIGNAL( in_UPDATE_MISS_PREDICTION  ,_param->_nb_inst_update,1);
+        DELETE1_SIGNAL( in_UPDATE_PREDICTION_IFETCH,_param->_nb_inst_update,1);
+        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          delete [] reg_stack [i];
+        delete [] reg_stack;
+        delete [] reg_TOP;
+        delete [] reg_BOTTOM;
+        delete [] reg_NB_ELT;
+        delete [] reg_PREDICT_TOP;
+        delete [] reg_PREDICT_BOTTOM;
+        delete [] reg_PREDICT_NB_ELT;
+        delete [] internal_PREDICT_ACK;
+        delete [] internal_PREDICT_HIT;
+        delete [] internal_DECOD_ACK;
+        delete [] internal_DECOD_HIT;
+        delete [] internal_UPDATE_ACK;
+      }
-    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] reg_stack;
-    delete [] reg_TOP;
-    delete [] reg_BOTTOM;
-    delete [] reg_NB_ELT;
-    delete [] reg_PREDICT_TOP;
-    delete [] reg_PREDICT_BOTTOM;
-    delete [] reg_PREDICT_NB_ELT;
-    delete [] internal_PREDICT_ACK;
-    delete [] internal_PREDICT_HIT;
-    delete [] internal_DECOD_ACK;
-    delete [] internal_DECOD_HIT;
-    delete [] internal_UPDATE_ACK;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/src/Return_Address_Stack_transition.cpp

r81	r88
191	191
192	192	// Scan full assoc !!!
193		for (uint32_t j=0; j<_param->_size_queue [i]; j++)
	193	for (uint32_t j=0; j<_param->_size_queue [context]; j++)
194	194	// Test if this slot is tagged with "predict" : if true, tagged as miss
195	195	if (reg_stack [context][j]._predict)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Prediction_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_min.cfg

r82	r88
36	36	1 1 +1 # dir_pht_size_address_share [2] [3]
37	37	2 2 +1 # ras_size_queue [0] [nb_context]
38		~~1 1~~ +1 # upt_size_queue [0] [nb_context]
	38	2 2 +1 # upt_size_queue [0] [nb_context]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_mono_context.cfg

-              r82
+              r88
       30      +1 # size_address
        4       *4 # nb_instruction             [0] [nb_context]
        1       +1 # nb_inst_decod              [0] [nb_decod_unit]
+       4       *4 # nb_inst_decod              [0] [nb_decod_unit]
        1       +1 # nb_inst_branch_predict
        1       +1 # nb_inst_branch_decod
        1       +1 # nb_inst_branch_update
        1       +1 # nb_inst_branch_complete
+       2       +1 # nb_inst_branch_decod
+       2       +1 # nb_inst_branch_update
+       2       +1 # nb_inst_branch_complete
        8       *4 # btb_size_queue
        2       +1 # btb_associativity
 …
        1       +1 # dir_pht_size_address_share [2] [3]
        4       *2 # ras_size_queue             [0] [nb_context]
        4       *4 # upt_size_queue             [0] [nb_context]
+       4       *2 # upt_size_queue             [0] [nb_context]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/config_multi_context.cfg

r82	r88
45	45	4 4 *4 # upt_size_queue [1] [nb_context]
46	46	4 4 *4 # upt_size_queue [2] [nb_context]
47		~~1 1~~ *4 # upt_size_queue [3] [nb_context]
	47	8 8 *4 # upt_size_queue [3] [nb_context]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/src/main.cpp

-              r82
+              r88
          _dir_pht_size_address_share,
          _ras_size_queue            ,
+         _upt_size_queue
+         _upt_size_queue            ,
+         true // is_toplevel
          );

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #define NB_ITERATION  1
 #define CYCLE_MAX     (128*NB_ITERATION)
+#define CYCLE_MAX     1000000
 #include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/SelfTest/include/test.h"
 …
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Prediction_unit * _Prediction_unit = new Prediction_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC1_SC_SIGNAL(out_PREDICT_PC_NEXT                    ,"out_PREDICT_PC_NEXT                    ",Taddress_t         ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_PREDICT_PC_NEXT_IS_DS_TAKE         ,"out_PREDICT_PC_NEXT_IS_DS_TAKE         ",Tcontrol_t         ,_param->_nb_context);
   ALLOC2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE         ,"out_PREDICT_INSTRUCTION_ENABLE         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE         ,"out_PREDICT_INSTRUCTION_ENABLE         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_instruction[it1]);
   ALLOC1_SC_SIGNAL(out_PREDICT_INST_IFETCH_PTR            ,"out_PREDICT_INST_IFETCH_PTR            ",Tinst_ifetch_ptr_t ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_PREDICT_BRANCH_STATE               ,"out_PREDICT_BRANCH_STATE               ",Tbranch_state_t    ,_param->_nb_context);
   ALLOC1_SC_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"out_PREDICT_BRANCH_UPDATE_PREDICTION_ID",Tprediction_ptr_t  ,_param->_nb_context);
   ALLOC2_SC_SIGNAL( in_DECOD_VAL                          ," in_DECOD_VAL                          ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL(out_DECOD_ACK                          ,"out_DECOD_ACK                          ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_CONTEXT_ID                   ," in_DECOD_CONTEXT_ID                   ",Tcontext_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR        ," in_DECOD_MATCH_INST_IFETCH_PTR        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_STATE                 ," in_DECOD_BRANCH_STATE                 ",Tbranch_state_t    ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID  ," in_DECOD_BRANCH_UPDATE_PREDICTION_ID  ",Tprediction_ptr_t  ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION             ," in_DECOD_BRANCH_CONDITION             ",Tbranch_condition_t,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION             ," in_DECOD_BRANCH_DIRECTION             ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                  ," in_DECOD_ADDRESS_SRC                  ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_DEST                 ," in_DECOD_ADDRESS_DEST                 ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_VAL                          ," in_DECOD_VAL                          ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL(out_DECOD_ACK                          ,"out_DECOD_ACK                          ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_CONTEXT_ID                   ," in_DECOD_CONTEXT_ID                   ",Tcontext_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR        ," in_DECOD_MATCH_INST_IFETCH_PTR        ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_STATE                 ," in_DECOD_BRANCH_STATE                 ",Tbranch_state_t    ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID  ," in_DECOD_BRANCH_UPDATE_PREDICTION_ID  ",Tprediction_ptr_t  ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION             ," in_DECOD_BRANCH_CONDITION             ",Tbranch_condition_t,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION             ," in_DECOD_BRANCH_DIRECTION             ",Tcontrol_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                  ," in_DECOD_ADDRESS_SRC                  ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_DECOD_ADDRESS_DEST                 ," in_DECOD_ADDRESS_DEST                 ",Taddress_t         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_VAL                ," in_BRANCH_COMPLETE_VAL                ",Tcontrol_t         ,_param->_nb_inst_branch_complete);
 …
   ALLOC1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST          ,"out_BRANCH_EVENT_ADDRESS_DEST          ",Taddress_t         ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_NB_BRANCH                    ,"out_DEPTH_NB_BRANCH                    ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_TAIL                         ,"out_DEPTH_TAIL                         ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_CURRENT                      ,"out_DEPTH_CURRENT                      ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_MIN                          ,"out_DEPTH_MIN                          ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_MAX                          ,"out_DEPTH_MAX                          ",Tdepth_t           ,_param->_nb_context);
   /********************************************************
 …
   INSTANCE1_SC_SIGNAL(_Prediction_unit,out_PREDICT_PC_NEXT                    ,_param->_nb_context);
   INSTANCE1_SC_SIGNAL(_Prediction_unit,out_PREDICT_PC_NEXT_IS_DS_TAKE         ,_param->_nb_context);
   INSTANCE2_SC_SIGNAL(_Prediction_unit,out_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit,out_PREDICT_INSTRUCTION_ENABLE         ,_param->_nb_context,_param->_nb_instruction[it1]);
   INSTANCE1_SC_SIGNAL(_Prediction_unit,out_PREDICT_BRANCH_STATE               ,_param->_nb_context);
+  for (uint32_t i=0; i<_param->_nb_context; i++)
+    {
+      if (_param->_have_port_inst_ifetch_ptr [i])
+        INSTANCE_SC_SIGNAL(_Prediction_unit,out_PREDICT_INST_IFETCH_PTR [i]);
+      if (_param->_have_port_depth [i])
+        INSTANCE_SC_SIGNAL(_Prediction_unit,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i]);
+    }
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_VAL                          ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit,out_DECOD_ACK                          ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  if (_param->_have_port_inst_ifetch_ptr)
+  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_PREDICT_INST_IFETCH_PTR            ,_param->_nb_context);
+  if (_param->_have_port_depth)
+  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_VAL                          ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit,out_DECOD_ACK                          ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   if (_param->_have_port_context_id)
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_CONTEXT_ID                   ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_MATCH_INST_IFETCH_PTR        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_STATE                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   if (_param->_have_port_max_depth)
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_UPDATE_PREDICTION_ID  ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_CONDITION             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_DIRECTION             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_ADDRESS_SRC                  ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_ADDRESS_DEST                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_CONTEXT_ID                   ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_MATCH_INST_IFETCH_PTR        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_STATE                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  if (_param->_have_port_depth)
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_UPDATE_PREDICTION_ID  ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_CONDITION             ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_BRANCH_DIRECTION             ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_ADDRESS_SRC                  ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Prediction_unit, in_DECOD_ADDRESS_DEST                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   INSTANCE1_SC_SIGNAL(_Prediction_unit, in_BRANCH_COMPLETE_VAL                ,_param->_nb_inst_branch_complete);
 …
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Prediction_unit, in_BRANCH_COMPLETE_CONTEXT_ID         ,_param->_nb_inst_branch_complete);
   if (_param->_have_port_max_depth)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Prediction_unit, in_BRANCH_COMPLETE_DEPTH              ,_param->_nb_inst_branch_complete);
   INSTANCE1_SC_SIGNAL(_Prediction_unit, in_BRANCH_COMPLETE_ADDRESS            ,_param->_nb_inst_branch_complete);
 …
   INSTANCE1_SC_SIGNAL(_Prediction_unit,out_BRANCH_EVENT_ADDRESS_DEST          ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_DEPTH_NB_BRANCH                    ,_param->_nb_context);
+  for (uint32_t i=0; i<_param->_nb_context; i++)
+    if (_param->_have_port_depth[i])
+      INSTANCE_SC_SIGNAL(_Prediction_unit,out_DEPTH_TAIL [i]);
+  if (_param->_have_port_depth)
+    {
+  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_DEPTH_CURRENT                      ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_DEPTH_MIN                          ,_param->_nb_context);
+    }
+  INSTANCE1_SC_SIGNAL(_Prediction_unit,out_DEPTH_MAX                          ,_param->_nb_context);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
 //const uint32_t seed = static_cast<uint32_t>(time(NULL));
+  const  int32_t percent_transaction_predict         = 80;
+  const  int32_t percent_transaction_decod           = 80;
+  const  int32_t percent_transaction_branch_complete = 80;
+  const  int32_t percent_transaction_branch_event    = 80;
   srand(seed);
+  uint32_t test1 = 1024; // TEST 1 : instruction without branch
+  uint32_t test2 = 1024; // TEST 2 : sequence : 1 branch, 1 delayed slot
   SC_START(0);
   LABEL("Initialisation");
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    {
+      in_PREDICT_VAL      [i]->write(0);
+      in_BRANCH_EVENT_ACK [i]->write(0);
+    }
+  for (uint32_t i=0; i<_param->_nb_decod_unit;++i)
+    for (uint32_t j=0; j<_param->_nb_inst_decod[i]; ++j)
+      {
+        in_DECOD_VAL [i][j]->write(0);
+      }
+  for (uint32_t i=0; i<_param->_nb_inst_branch_complete; ++i)
+    {
+      in_BRANCH_COMPLETE_VAL [i]->write(0);
+    }
   LABEL("Reset");
 …
   in_NRESET->write(1);
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    {
+      TEST(Tcontrol_t,out_PREDICT_ACK      [i]->read(),1); // Accept new request
+      TEST(Tcontrol_t,out_BRANCH_EVENT_VAL [i]->read(),0);
+      TEST(Tdepth_t  ,out_DEPTH_CURRENT    [i]->read(),0);
+      TEST(Tdepth_t  ,out_DEPTH_MIN        [i]->read(),0);
+      TEST(Tdepth_t  ,out_DEPTH_MAX        [i]->read(),0);
+    }
+  for (uint32_t i=0; i<_param->_nb_decod_unit;++i)
+    for (uint32_t j=0; j<_param->_nb_inst_decod[i]; ++j)
+      {
+        TEST(Tcontrol_t,out_DECOD_ACK [i][j]->read(),0); // No decod instruction
+      }
+  for (uint32_t i=0; i<_param->_nb_inst_branch_complete; ++i)
+    {
+      TEST(Tcontrol_t,out_BRANCH_COMPLETE_ACK [i]->read(),1); // Accept new branch_complete
+    }
   LABEL("Loop of Test");
+  Taddress_t PC_PREVIOUS           [_param->_nb_context];
+  Taddress_t PC_CURRENT            [_param->_nb_context];
+  Tcontrol_t PC_CURRENT_IS_DS_TAKE [_param->_nb_context];
   for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
+    {
       LABEL("Iteration %d",iteration);
+      // TEST 1 : instruction without branch
+      for (uint32_t test=0; test<test1; ++test)
+        {
+          for (uint32_t i=0; i<_param->_nb_context; ++i)
+            {
+              PC_CURRENT            [i] = (0x100000>>2);
+              PC_CURRENT_IS_DS_TAKE [i] = 0;
+              PC_PREVIOUS           [i] = PC_CURRENT[i]-1;
+            }
+          for (uint32_t i=0; i<_param->_nb_context; ++i)
+            {
+              in_PREDICT_VAL                   [i]->write((rand()%100)<percent_transaction_predict);
+              in_PREDICT_PC_PREVIOUS           [i]->write(PC_PREVIOUS          [i]);
+              in_PREDICT_PC_CURRENT            [i]->write(PC_CURRENT           [i]);
+              in_PREDICT_PC_CURRENT_IS_DS_TAKE [i]->write(PC_CURRENT_IS_DS_TAKE[i]);
+            }
+          SC_START(1);
+          for (uint32_t i=0; i<_param->_nb_context; ++i)
+            // Test if transaction
+            if (in_PREDICT_VAL [i]->read() and out_PREDICT_ACK [i]->read())
+              {
+                TEST(Taddress_t        ,out_PREDICT_PC_NEXT                     [i]->read(),PC_CURRENT[i]+_param->_nb_instruction[i]);
+                TEST(Tcontrol_t        ,out_PREDICT_PC_NEXT_IS_DS_TAKE          [i]->read(),0);
+                for (uint32_t j=0; j<_param->_nb_instruction[i]; ++j)
+                TEST(Tcontrol_t        ,out_PREDICT_INSTRUCTION_ENABLE          [i][j]->read(),1);
+                TEST(Tinst_ifetch_ptr_t,out_PREDICT_INST_IFETCH_PTR             [i]->read(),0);
+                TEST(Tbranch_state_t   ,out_PREDICT_BRANCH_STATE                [i]->read(),BRANCH_STATE_NONE);
+                TEST(Tprediction_ptr_t ,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i]->read(),0);
+                PC_PREVIOUS           [i] = PC_CURRENT [i];
+                PC_CURRENT            [i] = out_PREDICT_PC_NEXT            [i]->read();
+                PC_CURRENT_IS_DS_TAKE [i] = out_PREDICT_PC_NEXT_IS_DS_TAKE [i]->read();
+              }
+          // Test another output
+          for (uint32_t i=0; i<_param->_nb_context; ++i)
+            {
+              TEST(Tcontrol_t,out_BRANCH_EVENT_VAL [i]->read(),0);
+              TEST(Tdepth_t  ,out_DEPTH_CURRENT    [i]->read(),0);
+              TEST(Tdepth_t  ,out_DEPTH_MIN        [i]->read(),0);
+              TEST(Tdepth_t  ,out_DEPTH_MAX        [i]->read(),0);
+            }
+          for (uint32_t i=0; i<_param->_nb_decod_unit;++i)
+            for (uint32_t j=0; j<_param->_nb_inst_decod[i]; ++j)
+              {
+                TEST(Tcontrol_t,out_DECOD_ACK [i][j]->read(),0); // No decod instruction
+              }
+          for (uint32_t i=0; i<_param->_nb_inst_branch_complete; ++i)
+            {
+              TEST(Tcontrol_t,out_BRANCH_COMPLETE_ACK [i]->read(),1); // Accept new branch_complete
+            }
+        }
       SC_START(1);
 …
   DELETE1_SC_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context);
   DELETE2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE       ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
   DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+  DELETE2_SC_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE       ,_param->_nb_context,_param->_nb_instruction[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+  DELETE2_SC_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
   DELETE1_SC_SIGNAL( in_BRANCH_COMPLETE_VAL            ,_param->_nb_inst_branch_complete);
 …
   DELETE1_SC_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST   ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_DEPTH_NB_BRANCH    ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_DEPTH_TAIL         ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_DEPTH_CURRENT      ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_DEPTH_MIN          ,_param->_nb_context);
+  DELETE1_SC_SIGNAL(out_DEPTH_MAX          ,_param->_nb_context);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/Makefile

r81	r88
24	24	library_clean : Update_Prediction_Table_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/config_min.cfg

-              r82
+              r88
 Update_Prediction_Table
        1       +1      # nb_context
+       4       *4      # size_queue             [0] [nb_context]
+       1       *4      # size_upt_queue         [0] [nb_context]
+       1       *4      # size_ufpt_queue        [0] [nb_context]
       32      *2      # size_address
        1       *4      # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/config_mono_context.cfg

-              r81
+              r88
 Update_Prediction_Table
        1       +1      # nb_context
+       4       *4      # size_queue             [0] [nb_context]
+       8       *2      # size_upt_queue         [0] [nb_context]
+       4       *2      # size_ufpt_queue        [0] [nb_context]
       32      *2      # size_address
        4       *4      # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/config_multi_context.cfg

-              r81
+              r88
 Update_Prediction_Table
        4       +1      # nb_context
+       4       *4      # size_queue             [0] [nb_context]
+       1       *4      # size_queue             [1] [nb_context]
+       8       *4      # size_queue             [2] [nb_context]
+       2       *4      # size_queue             [3] [nb_context]
+       4       *4      # size_upt_queue         [0] [nb_context]
+       2       *4      # size_upt_queue         [1] [nb_context]
+       8       *4      # size_upt_queue         [2] [nb_context]
+       1       *4      # size_upt_queue         [3] [nb_context]
+       4       *4      # size_ufpt_queue        [0] [nb_context]
+       1       *4      # size_ufpt_queue        [1] [nb_context]
+       2       *4      # size_ufpt_queue        [2] [nb_context]
+       1       *4      # size_ufpt_queue        [3] [nb_context]
       32      *2      # size_address
        4       *4      # nb_inst_predict

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/src/main.cpp

-              r81
+              r88
   err (_("list_params is :\n"));
   err (_(" * nb_context                           (uint32_t)\n"));
+  err (_(" * size_queue              [nb_context] (uint32_t)\n"));
+  err (_(" * size_upt_queue          [nb_context] (uint32_t)\n"));
+  err (_(" * size_ufpt_queue         [nb_context] (uint32_t)\n"));
   err (_(" * size_address                         (uint32_t)\n"));
   err (_(" * nb_inst_predict                      (uint32_t)\n"));
 …
   uint32_t   _nb_context              = fromString<uint32_t>(argv[x++]);
   if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context))
+  if (argc != static_cast<int>(2+NB_PARAMS+3*_nb_context))
     usage (argc, argv);
   uint32_t * _size_queue              = new uint32_t [_nb_context];
+  uint32_t * _size_upt_queue              = new uint32_t [_nb_context];
   for (uint32_t i=0; i<_nb_context; i++)
+    _size_queue [i] = fromString<uint32_t>(argv[x++]);
+    _size_upt_queue  [i] = fromString<uint32_t>(argv[x++]);
+  uint32_t * _size_ufpt_queue             = new uint32_t [_nb_context];
+  for (uint32_t i=0; i<_nb_context; i++)
+    _size_ufpt_queue [i] = fromString<uint32_t>(argv[x++]);
   uint32_t   _size_address            = fromString<uint32_t>(argv[x++]);
   uint32_t   _nb_inst_predict         = fromString<uint32_t>(argv[x++]);
 …
       morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::Parameters * param = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::Parameters
         (_nb_context             ,
+         _size_queue             ,
+         _size_upt_queue         ,
+         _size_ufpt_queue        ,
          _size_address           ,
          _nb_inst_predict        ,
 …
          _nb_inst_update         ,
          _size_history           ,
+         _size_ras_index         );
+         _size_ras_index         ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());
 …
   delete [] _size_ras_index;
+  delete [] _size_queue;
+  delete [] _size_ufpt_queue;
+  delete [] _size_upt_queue;
   return (_return);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/SelfTest/src/test.cpp

-              r82
+              r88
 /*
  * $Id$
+ * $id: test.cpp 82 2008-05-01 16:48:45Z rosiere $
+ *
  * [ Description ]
 …
 #include "Common/include/Test.h"
 #include "Behavioural/include/Allocation.h"
+typedef struct
+{
+  uint32_t            ufpt_ptr    ;
+  uint32_t            upt_ptr     ;
+  Tcontext_t          context     ;
+  Taddress_t          address_src ;
+  Taddress_t          address_dest;
+  Taddress_t          address_good;
+  Tbranch_condition_t condition   ;
+  Tcontrol_t          take        ;
+  Tcontrol_t          take_good   ;
+  Tcontrol_t          flag        ;
+  Tcontrol_t          is_accurate ;
+  Thistory_t          history     ;
+  Taddress_t          ras_address ;
+  Tptr_t              ras_index   ;
+  Tcontrol_t          miss_ifetch ;
+  Tcontrol_t          miss_decod  ;
+  Tcontrol_t          miss_commit ;
+} request_t;
 void test (string name,
 …
   ALLOC1_SC_SIGNAL( in_PREDICT_RAS_ADDRESS            ," in_PREDICT_RAS_ADDRESS            ",Taddress_t         ,_param->_nb_inst_predict);
   ALLOC1_SC_SIGNAL( in_PREDICT_RAS_INDEX              ," in_PREDICT_RAS_INDEX              ",Tptr_t             ,_param->_nb_inst_predict);
 //ALLOC1_SC_SIGNAL(out_PREDICT_UPDATE_PREDICTION_ID   ,"out_PREDICT_UPDATE_PREDICTION_ID   ",Tprediction_ptr_t  ,_param->_nb_inst_predict);
+  ALLOC1_SC_SIGNAL(out_PREDICT_UPDATE_PREDICTION_ID   ,"out_PREDICT_UPDATE_PREDICTION_ID   ",Tprediction_ptr_t  ,_param->_nb_inst_predict);
   ALLOC1_SC_SIGNAL( in_DECOD_VAL                      ," in_DECOD_VAL                      ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL(out_DECOD_ACK                      ,"out_DECOD_ACK                      ",Tcontrol_t         ,_param->_nb_inst_decod);
 …
   ALLOC1_SC_SIGNAL( in_DECOD_UPDATE_PREDICTION_ID     ," in_DECOD_UPDATE_PREDICTION_ID     ",Tprediction_ptr_t  ,_param->_nb_inst_decod);
 //ALLOC1_SC_SIGNAL(out_DECOD_DEPTH                    ,"out_DECOD_DEPTH                    ",Tdepth_t           ,_param->_nb_inst_decod);
+  ALLOC1_SC_SIGNAL( in_DECOD_IS_ACCURATE              ," in_DECOD_IS_ACCURATE              ",Tcontrol_t         ,_param->_nb_inst_decod);
   ALLOC1_SC_SIGNAL( in_BRANCH_COMPLETE_VAL            ," in_BRANCH_COMPLETE_VAL            ",Tcontrol_t         ,_param->_nb_inst_branch_complete);
 …
   ALLOC1_SC_SIGNAL(out_UPDATE_RAS_INDEX               ,"out_UPDATE_RAS_INDEX               ",Tptr_t             ,_param->_nb_inst_update);
   ALLOC1_SC_SIGNAL(out_UPDATE_RAS_PREDICTION_IFETCH   ,"out_UPDATE_RAS_PREDICTION_IFETCH   ",Tcontrol_t         ,_param->_nb_inst_update);
+  ALLOC1_SC_SIGNAL(out_DEPTH_NB_BRANCH                ,"out_DEPTH_NB_BRANCH                ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_TAIL                     ,"out_DEPTH_TAIL                     ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_CURRENT                  ,"out_DEPTH_CURRENT                  ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_MIN                      ,"out_DEPTH_MIN                      ",Tdepth_t           ,_param->_nb_context);
+  ALLOC1_SC_SIGNAL(out_DEPTH_MAX                      ,"out_DEPTH_MAX                      ",Tdepth_t           ,_param->_nb_context);
   /********************************************************
 …
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_RAS_ADDRESS            ,_param->_nb_inst_predict);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_PREDICT_RAS_INDEX              ,_param->_nb_inst_predict);
 //if (_param->_have_port_depth)
 //INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_PREDICT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_predict);
+  if (_param->_have_port_depth)
+  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_PREDICT_UPDATE_PREDICTION_ID   ,_param->_nb_inst_predict);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_VAL                      ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DECOD_ACK                      ,_param->_nb_inst_decod);
 …
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_MISS_IFETCH              ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_MISS_DECOD               ,_param->_nb_inst_decod);
   if (_param->_have_port_max_depth)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_UPDATE_PREDICTION_ID     ,_param->_nb_inst_decod);
 //if (_param->_have_port_depth)
 //INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DECOD_DEPTH                    ,_param->_nb_inst_decod);
+  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_DECOD_IS_ACCURATE              ,_param->_nb_inst_decod);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_VAL            ,_param->_nb_inst_branch_complete);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_BRANCH_COMPLETE_ACK            ,_param->_nb_inst_branch_complete);
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_CONTEXT_ID     ,_param->_nb_inst_branch_complete);
   if (_param->_have_port_max_depth)
+  if (_param->_have_port_depth)
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_DEPTH          ,_param->_nb_inst_branch_complete);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_COMPLETE_ADDRESS        ,_param->_nb_inst_branch_complete);
 …
 //   if (_param->_have_port_context_id)
 //   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_EVENT_CONTEXT_ID     ,_param->_nb_context);
 //   if (_param->_have_port_max_depth)
+//   if (_param->_have_port_depth)
 //   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_EVENT_DEPTH          ,_param->_nb_context);
 //   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table, in_BRANCH_EVENT_ADDRESS        ,_param->_nb_context);
 …
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_INDEX               ,_param->_nb_inst_update);
   INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_UPDATE_RAS_PREDICTION_IFETCH   ,_param->_nb_inst_update);
   for (uint32_t i=0; i<_param->_nb_context; i++)
+  if (_param->_have_port_depth)
+    {
+      if (_param->_have_port_depth[i])
+        {
+          INSTANCE_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_TAIL      [i]);
+        }
+      INSTANCE_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_NB_BRANCH [i]);
+  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_CURRENT                  ,_param->_nb_context);
+  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_MIN                      ,_param->_nb_context);
+    }
+  INSTANCE1_SC_SIGNAL(_Update_Prediction_Table,out_DEPTH_MAX                      ,_param->_nb_context);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
   const  int32_t percent_transaction_update          = 75;
+  std::list<request_t> ufpt;
+  std::list<request_t> upt;
   SC_START(0);
   LABEL("Initialisation");
 …
   in_NRESET->write(1);
+  for (uint32_t i=0; i<_param->_nb_context; i++)
+  Tdepth_t ufpt_bottom [_param->_nb_context];
+  Tdepth_t ufpt_top    [_param->_nb_context];
+  Tdepth_t upt_bottom  [_param->_nb_context];
+  Tdepth_t upt_top     [_param->_nb_context];
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    {
+      PORT_WRITE(in_BRANCH_EVENT_ACK [i],1);
+      ufpt_bottom [i] = 0;
+      ufpt_top    [i] = 0;
+      upt_bottom  [i] = 0;
+      upt_top     [i] = 0;
+    }
+  LABEL("Loop of Test");
+  for (uint32_t i=0; i<_param->_nb_context; ++i)
+    {
+      TEST(Tdepth_t,out_DEPTH_CURRENT [i]->read(),upt_top    [i]);
+      TEST(Tdepth_t,out_DEPTH_MIN     [i]->read(),upt_bottom [i]);
+      TEST(Tdepth_t,out_DEPTH_MAX     [i]->read(),upt_top    [i]);
+    }
   for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
+    {
       LABEL("Iteration %d",iteration);
+      for (uint32_t i=0; i<_param->_nb_inst_predict; ++i)
+        in_PREDICT_VAL         [i]->write(0);
+      for (uint32_t i=0; i<_param->_nb_inst_decod; ++i)
+        in_DECOD_VAL           [i]->write(0);
+      for (uint32_t i=0; i<_param->_nb_inst_branch_complete; ++i)
+        in_BRANCH_COMPLETE_VAL [i]->write(0);
+      for (uint32_t i=0; i<_param->_nb_context; ++i)
+        in_BRANCH_EVENT_ACK    [i]->write(0);
+      for (uint32_t i=0; i<_param->_nb_inst_update; ++i)
+        in_UPDATE_ACK          [i]->write(0);
+      //---------------------------------------------------------------------
+      //---------------------------------------------------------------------
+      // COMMON CASE
+      //---------------------------------------------------------------------
+      //---------------------------------------------------------------------
+      if (1)
+      {
         uint32_t context = rand() % _param->_nb_context;
+//      LABEL("KANE : %d",context);
+        LABEL("PREDICT - fill the queue");
+        {
+          LABEL("PREDICT - fill the queue");
           uint32_t port = rand() % _param->_nb_inst_predict;
+          LABEL("  * context : %d",context);
+          LABEL("  * port    : %d",port);
           for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+          for (uint32_t i=0; i<_param->_size_ufpt_queue[context]; i++)
+            {
+              bool find = false;
+              request_t request;
+              request.context          = context;
+              request.address_src      = 0xdeadbeef+i;
+              request.address_dest     = 0x21071981+i;
+              request.address_good     = request.address_dest;
+              request.condition        = BRANCH_CONDITION_FLAG_SET;
+              request.take             = 1;
+              request.take_good        = 1;
+              request.flag             = (request.condition == BRANCH_CONDITION_FLAG_SET)?request.take_good:(not request.take_good);
+              request.is_accurate      = true;
+              request.miss_ifetch      = false;
+              request.miss_decod       = false;
+              request.miss_commit      = false;
+              request.history          = i;
+              request.ras_address      = 0xdeaddead+i;
+              request.ras_index        = (0x12345678+i)%_param->_size_ras_index[context];
+              request.ufpt_ptr         = ufpt_top [context];
+//            request.upt_ptr;
+              bool have_transaction = false;
               do
+                {
                   in_PREDICT_VAL              [port]->write((rand()%100)<percent_transaction_predict);
+                  in_PREDICT_CONTEXT_ID       [port]->write(context);
+                  in_PREDICT_BTB_ADDRESS_SRC  [port]->write(0xdeadbeef+i);
+                  in_PREDICT_BTB_ADDRESS_DEST [port]->write(0x21071981+i);
+                  in_PREDICT_BTB_CONDITION    [port]->write(BRANCH_CONDITION_FLAG_SET);
+                  in_PREDICT_BTB_LAST_TAKE    [port]->write(1);
+                  in_PREDICT_BTB_IS_ACCURATE  [port]->write((rand()%100)<percent_transaction_predict);
+                  in_PREDICT_DIR_HISTORY      [port]->write(i);
+                  in_PREDICT_RAS_ADDRESS      [port]->write(0xdeaddead+i);
+                  in_PREDICT_RAS_INDEX        [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
+                  if (_param->_have_port_depth[context])
+                    {
+                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                    }
+                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i);
+                  in_PREDICT_CONTEXT_ID       [port]->write(request.context     );
+                  in_PREDICT_BTB_ADDRESS_SRC  [port]->write(request.address_src );
+                  in_PREDICT_BTB_ADDRESS_DEST [port]->write(request.address_dest);
+                  in_PREDICT_BTB_CONDITION    [port]->write(request.condition   );
+                  in_PREDICT_BTB_LAST_TAKE    [port]->write(request.take        );
+                  in_PREDICT_BTB_IS_ACCURATE  [port]->write(request.is_accurate );
+                  in_PREDICT_DIR_HISTORY      [port]->write(request.history     );
+                  in_PREDICT_RAS_ADDRESS      [port]->write(request.ras_address );
+                  in_PREDICT_RAS_INDEX        [port]->write(request.ras_index   );
+                  if (_param->_have_port_depth)
+                  TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+                  TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
+                  SC_START(0);
+                  LABEL("PREDICT         [%d] %d - %d (accurate : %d).",port,in_PREDICT_VAL [port]->read(),out_PREDICT_ACK [port]->read(), in_PREDICT_BTB_IS_ACCURATE [port]->read());
+                  SC_START(0); // fct melay
+                  LABEL("PREDICT         [%d] %d - %d (accurate : %d).",
+                        port,
+                         in_PREDICT_VAL [port]->read(),
+                        out_PREDICT_ACK [port]->read(),
+                         in_PREDICT_BTB_IS_ACCURATE [port]->read());
                   if (in_PREDICT_VAL [port]->read() and out_PREDICT_ACK [port]->read())
+                    {
                       LABEL("PREDICT         [%d] - Transaction accepted",port);
+                      find = true;
+                      have_transaction = true;
+                      if (_param->_have_port_depth)
+                      TEST(Tprediction_ptr_t,out_PREDICT_UPDATE_PREDICTION_ID [port]->read(),ufpt_top [context]);
+                      ufpt_top [context] = (ufpt_top [context]+1)%_param->_size_ufpt_queue[context];
+                    }
                   SC_START(1);
                 } while (not find);
+              in_PREDICT_VAL              [port]->write(0);
+              if (_param->_have_port_depth[context])
+                {
                   TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                }
                   TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i+1);
+                  SC_START(1); // transition
+                } while (not have_transaction);
+              ufpt.push_back(request);
+              in_PREDICT_VAL [port]->write(0);
+              if (_param->_have_port_depth)
+              TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+              TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
+            }
+        }
+        LABEL("DECOD - hit ifetch");
+        {
+        {
+          LABEL("DECOD");
           uint32_t port = rand() % _param->_nb_inst_decod;
+          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+          LABEL("  * context : %d",context);
+          LABEL("  * port    : %d",port);
+          for (uint32_t i=0; i<_param->_size_ufpt_queue[context]; i++)
+            {
+              bool find = false;
+              request_t request = ufpt.front();
+              bool have_transaction = false;
               do
+                {
                   in_DECOD_VAL                  [port]->write((rand()%100)<percent_transaction_decod);
+                  in_DECOD_CONTEXT_ID           [port]->write(context);
+                  in_DECOD_BTB_ADDRESS_SRC      [port]->write(0xdeadbeef+i);
+                  in_DECOD_BTB_ADDRESS_DEST     [port]->write(0x21071981+i);
+                  in_DECOD_BTB_CONDITION        [port]->write(BRANCH_CONDITION_FLAG_SET);
+                  in_DECOD_BTB_LAST_TAKE        [port]->write(1);
+                  in_DECOD_RAS_ADDRESS          [port]->write(0xdeaddead+i);
+                  in_DECOD_RAS_INDEX            [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
+                  in_DECOD_MISS_IFETCH          [port]->write(false);
+                  in_DECOD_MISS_DECOD           [port]->write(false);
+                  in_DECOD_UPDATE_PREDICTION_ID [port]->write(i);
+                  if (_param->_have_port_depth[context])
+                    {
+                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                    }
+                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+                  SC_START(0);
+                  LABEL("DECOD           [%d] %d - %d.",port,in_DECOD_VAL [port]->read(),out_DECOD_ACK [port]->read());
+                  in_DECOD_CONTEXT_ID           [port]->write(request.context     );
+                  in_DECOD_BTB_ADDRESS_SRC      [port]->write(request.address_src );
+                  in_DECOD_BTB_ADDRESS_DEST     [port]->write(request.address_dest);
+                  in_DECOD_BTB_CONDITION        [port]->write(request.condition   );
+                  in_DECOD_BTB_LAST_TAKE        [port]->write(request.take        );
+                  in_DECOD_RAS_ADDRESS          [port]->write(request.ras_address );
+                  in_DECOD_RAS_INDEX            [port]->write(request.ras_index   );
+                  in_DECOD_UPDATE_PREDICTION_ID [port]->write(request.ufpt_ptr    );
+                  in_DECOD_MISS_IFETCH          [port]->write(request.miss_ifetch );
+                  in_DECOD_MISS_DECOD           [port]->write(request.miss_decod  );
+                  in_DECOD_IS_ACCURATE          [port]->write(request.is_accurate );
+                  SC_START(0); // fct melay
+                  LABEL("DECOD           [%d] %d - %d",
+                        port,
+                         in_PREDICT_VAL [port]->read(),
+                        out_PREDICT_ACK [port]->read());
                   if (in_DECOD_VAL [port]->read() and out_DECOD_ACK [port]->read())
+                    {
+                      LABEL("DECOD           [%d] - Transaction accepted",port);
+                      find = true;
+                      LABEL("DECOD          [%d] - Transaction accepted",port);
+                      have_transaction = true;
+                      request.upt_ptr = upt_top [context];
+                      upt.push_back(request);
+                      ufpt.pop_front();
+                      upt_top [context] = (upt_top [context]+1)%_param->_size_upt_queue[context];
+                    }
+                  SC_START(1);
+                } while (not find);
+                  SC_START(1); // transition
+                } while (not have_transaction);
               in_DECOD_VAL              [port]->write(0);
+              if (_param->_have_port_depth[context])
+                {
+                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                }
+                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+            }
+        }
+              if (_param->_have_port_depth)
+              TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+              TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
+            }
+        }
+        {
+          LABEL("BRANCH_COMPLETE - hit ifetch");
         LABEL("BRANCH_COMPLETE - hit ifetch");
+          uint32_t port = rand() % _param->_nb_inst_branch_complete;
+        {
+          uint32_t port = rand() % _param->_nb_inst_branch_complete;
+          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+          LABEL("  * port    : %d",port);
+          std::list<request_t>::iterator it_upt = upt.begin();
+//        for (uint32_t i=0; i<_param->_size_ufpt_queue[context]; i++)
+          for (uint32_t i=0; i<upt.size(); i++)
+            {
+              bool find = false;
+              bool have_transaction = false;
               do
+                {
+                  in_BRANCH_COMPLETE_VAL                  [port]->write((rand()%100)<percent_transaction_branch_complete);
+                  in_BRANCH_COMPLETE_CONTEXT_ID           [port]->write(context);
+                  in_BRANCH_COMPLETE_DEPTH                [port]->write(i);
+                  in_BRANCH_COMPLETE_ADDRESS              [port]->write(0xcacacaca+i);
+                  in_BRANCH_COMPLETE_FLAG                 [port]->write(1);
+                  if (_param->_have_port_depth[context])
+                    {
+                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                    }
+                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+                  in_BRANCH_COMPLETE_VAL        [port]->write((rand()%100)<percent_transaction_branch_complete);
+                  in_BRANCH_COMPLETE_CONTEXT_ID [port]->write(it_upt->context     );
+                  in_BRANCH_COMPLETE_DEPTH      [port]->write(it_upt->upt_ptr     );
+                  in_BRANCH_COMPLETE_ADDRESS    [port]->write(it_upt->address_good);
+                  in_BRANCH_COMPLETE_FLAG       [port]->write(it_upt->flag        );
+                  if (_param->_have_port_depth)
+                  TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+                  TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
                   SC_START(0);
 …
+                    {
                       LABEL("BRANCH_COMPLETE [%d] - Transaction accepted",port);
                       find = true;
+                      have_transaction = true;
+                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_MISS_PREDICTION[port]->read(),0);
+                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_TAKE           [port]->read(),1);
+                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_SRC    [port]->read(),0xdeadbeef+i);
+                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),0x21071981+i);
+                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_MISS_PREDICTION[port]->read(),it_upt->miss_commit );
+                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_TAKE           [port]->read(),it_upt->take_good   );
+                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_SRC    [port]->read(),it_upt->address_src );
+                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),it_upt->address_good);
+                      it_upt ++;
+                    }
                   SC_START(1);
+                } while (not find);
               in_BRANCH_COMPLETE_VAL              [port]->write(0);
+                } while (not have_transaction);
+              in_BRANCH_COMPLETE_VAL [port]->write(0);
+              if (_param->_have_port_depth[context])
+                {
+                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                }
+                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+              if (_param->_have_port_depth)
+              TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+              TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
+            }
+        }
+        {
+          LABEL("UPDATE - hit ifetch");
         LABEL("UPDATE - hit ifetch");
+          uint32_t port = 0;
+        {
+          uint32_t port = 0; //rand() % _param->_nb_inst_update;
+          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+          LABEL("  * port    : %d",port);
+          std::list<request_t>::iterator it_upt = upt.begin();
+//        for (uint32_t i=0; i<_param->_size_ufpt_queue[context]; i++)
+          for (uint32_t i=0; i<upt.size(); i++)
+            {
+              bool find = false;
+              LABEL("Address_src (-1): %.8x (%d)",out_UPDATE_BTB_ADDRESS_SRC [i]->read(),upt.size());
+              bool have_transaction = false;
               do
+                {
+                  LABEL("Address_src (0) : %.8x",out_UPDATE_BTB_ADDRESS_SRC [i]->read());
                   in_UPDATE_ACK [port]->write((rand()%100)<percent_transaction_update);
+//                   if (_param->_have_port_depth)
+//                   TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+//                   TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
+                  LABEL("Address_src (1) : %.8x",out_UPDATE_BTB_ADDRESS_SRC [i]->read());
                   SC_START(0);
+                  LABEL("Address_src (2) : %.8x",out_UPDATE_BTB_ADDRESS_SRC [i]->read());
+                  LABEL("UPDATE [%d] %d - %d.",port,out_UPDATE_VAL [port]->read(),in_UPDATE_ACK [port]->read());
                   if (out_UPDATE_VAL [port]->read() and in_UPDATE_ACK [port]->read())
+                    {
                       LABEL("UPDATE [%d] - Transaction accepted",port);
+                      find = true;
+                      TEST(Tcontext_t         ,out_UPDATE_CONTEXT_ID            [port]->read(), context);
+                      TEST(Tcontrol_t         ,out_UPDATE_MISS_PREDICTION       [port]->read(), 0);
+                      TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [port]->read(), 1);
+                      TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [port]->read(), 1);
+                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_SRC       [port]->read(), 0xdeadbeef+i);
+                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_DEST      [port]->read(), 0x21071981+i);
+                      TEST(Tbranch_condition_t,out_UPDATE_BTB_CONDITION         [port]->read(), BRANCH_CONDITION_FLAG_SET);
+                      TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [port]->read(), 1);
+                      if (_param->_have_port_history)
+                        TEST(Thistory_t         ,out_UPDATE_DIR_HISTORY           [port]->read(), i);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [port]->read(), 0);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PUSH              [port]->read(), 0);
+                      TEST(Taddress_t         ,out_UPDATE_RAS_ADDRESS           [port]->read(), 0xdeaddead+i);
+                      TEST(Tptr_t             ,out_UPDATE_RAS_INDEX             [port]->read(), (0x12345678+i)%_param->_size_ras_index[context]);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PREDICTION_IFETCH [port]->read(), 1);
+                      have_transaction = true;
+                      if (_param->_have_port_context_id)
+                      TEST(Tcontext_t         ,out_UPDATE_CONTEXT_ID            [i]->read(),it_upt->context);
+                      TEST(Tcontrol_t         ,out_UPDATE_MISS_PREDICTION       [i]->read(),it_upt->miss_commit);
+                      TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [i]->read(),it_upt->flag);
+                      TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [i]->read(),update_btb(it_upt->condition));
+                      if (update_btb(it_upt->condition))
+                        {
+                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_SRC       [i]->read(),it_upt->address_src);
+                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_DEST      [i]->read(),it_upt->address_dest);
+                      TEST(Tbranch_condition_t,out_UPDATE_BTB_CONDITION         [i]->read(),it_upt->condition);
+                        }
+                      TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [i]->read(),update_dir(it_upt->condition));
+                      if (update_dir(it_upt->condition))
+                      if (_param->_have_port_history)
+                      TEST(Thistory_t         ,out_UPDATE_DIR_HISTORY           [i]->read(),it_upt->history);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [i]->read(),update_ras(it_upt->condition));
+                      if (update_ras(it_upt->condition))
+                        {
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PUSH              [i]->read(),push_ras  (it_upt->condition));
+                      TEST(Taddress_t         ,out_UPDATE_RAS_ADDRESS           [i]->read(),it_upt->ras_address);
+                      TEST(Tptr_t             ,out_UPDATE_RAS_INDEX             [i]->read(),it_upt->ras_index);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PREDICTION_IFETCH [i]->read(),not it_upt->miss_ifetch);
+                        }
+                      ++ it_upt;
+                    }
                   SC_START(1);
+                } while (not find);
+              in_UPDATE_ACK              [port]->write(0);
+                  LABEL("Address_src (3) : %.8x",out_UPDATE_BTB_ADDRESS_SRC [i]->read());
+                } while (not have_transaction);
+              LABEL("Address_src (4) : %.8x",out_UPDATE_BTB_ADDRESS_SRC [i]->read());
+              in_UPDATE_ACK [port]->write(0);
+              LABEL("Address_src (5) : %.8x",out_UPDATE_BTB_ADDRESS_SRC [i]->read());
+//               if (_param->_have_port_depth)
+//               TEST(Tdepth_t,out_DEPTH_MIN [context]->read(), upt_bottom [context]);
+//               TEST(Tdepth_t,out_DEPTH_MAX [context]->read(), upt_top [context]);
+            }
+          LABEL("Wait a moment");
+          SC_START(2*_param->_size_queue[context]);
+          // wait the garbage collector
+          while ((not (_param->_have_port_depth[context]) or (out_DEPTH_TAIL     [context]->read() != 0)) and
+                 (out_DEPTH_NB_BRANCH[context]->read() != 0))
+            {
+              LABEL("DEPTH [%d] nb_branch : %d - tail : %d",context,out_DEPTH_NB_BRANCH[context]->read(), out_DEPTH_TAIL [context]->read());
+              SC_START(1);
+            }
+          upt.clear();
+        }
+        // Wait Garbage Collector
+        {
+          upt_bottom [context] = (upt_bottom [context]+_param->_size_ufpt_queue[context])%_param->_size_upt_queue[context];
+//        upt_top    [context] = (upt_top    [context]);
+          while ((upt_bottom [context] != out_DEPTH_MIN [context]->read()) or
+                 (upt_top    [context] != out_DEPTH_MAX [context]->read()))
+            SC_START(1);
+        }
+      }
+      {
+        uint32_t context = rand() % _param->_nb_context;
+//      LABEL("KANE : %d",context);
+        LABEL("PREDICT - fill the queue");
+        {
+          uint32_t port = rand() % _param->_nb_inst_predict;
+          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+            {
+              bool find = false;
+              do
+                {
+                  in_PREDICT_VAL              [port]->write((rand()%100)<percent_transaction_predict);
+                  in_PREDICT_CONTEXT_ID       [port]->write(context);
+                  in_PREDICT_BTB_ADDRESS_SRC  [port]->write(0xdeadbeef+i);
+                  in_PREDICT_BTB_ADDRESS_DEST [port]->write(0x21071981+i);
+                  in_PREDICT_BTB_CONDITION    [port]->write(BRANCH_CONDITION_FLAG_SET);
+                  in_PREDICT_BTB_LAST_TAKE    [port]->write(1);
+                  in_PREDICT_BTB_IS_ACCURATE  [port]->write((rand()%100)<percent_transaction_predict);
+                  in_PREDICT_DIR_HISTORY      [port]->write(i);
+                  in_PREDICT_RAS_ADDRESS      [port]->write(0xdeaddead+i);
+                  in_PREDICT_RAS_INDEX        [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
+                  if (_param->_have_port_depth[context])
+                    {
+                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                    }
+                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i);
+                  SC_START(0);
+                  LABEL("PREDICT         [%d] %d - %d (accurate : %d).",port,in_PREDICT_VAL [port]->read(),out_PREDICT_ACK [port]->read(), in_PREDICT_BTB_IS_ACCURATE [port]->read());
+                  if (in_PREDICT_VAL [port]->read() and out_PREDICT_ACK [port]->read())
+                    {
+                      LABEL("PREDICT         [%d] - Transaction accepted",port);
+                      find = true;
+                    }
+                  SC_START(1);
+                } while (not find);
+              in_PREDICT_VAL              [port]->write(0);
+              if (_param->_have_port_depth[context])
+                {
+                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                }
+                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), i+1);
+            }
+        }
+        LABEL("DECOD - hit ifetch");
+        {
+          uint32_t port = rand() % _param->_nb_inst_decod;
+          for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+            {
+              bool find = false;
+              do
+                {
+                  in_DECOD_VAL                  [port]->write((rand()%100)<percent_transaction_decod);
+                  in_DECOD_CONTEXT_ID           [port]->write(context);
+                  in_DECOD_BTB_ADDRESS_SRC      [port]->write(0xdeadbeef+i);
+                  in_DECOD_BTB_ADDRESS_DEST     [port]->write(0x21071981+i);
+                  in_DECOD_BTB_CONDITION        [port]->write(BRANCH_CONDITION_FLAG_SET);
+                  in_DECOD_BTB_LAST_TAKE        [port]->write(1);
+                  in_DECOD_RAS_ADDRESS          [port]->write(0xdeaddead+i);
+                  in_DECOD_RAS_INDEX            [port]->write((0x12345678+i)%_param->_size_ras_index[context]);
+                  in_DECOD_MISS_IFETCH          [port]->write(false);
+                  in_DECOD_MISS_DECOD           [port]->write(false);
+                  in_DECOD_UPDATE_PREDICTION_ID [port]->write(i);
+                  if (_param->_have_port_depth[context])
+                    {
+                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                    }
+                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+                  SC_START(0);
+                  LABEL("DECOD           [%d] %d - %d.",port,in_DECOD_VAL [port]->read(),out_DECOD_ACK [port]->read());
+                  if (in_DECOD_VAL [port]->read() and out_DECOD_ACK [port]->read())
+                    {
+                      LABEL("DECOD           [%d] - Transaction accepted",port);
+                      find = true;
+                    }
+                  SC_START(1);
+                } while (not find);
+              in_DECOD_VAL              [port]->write(0);
+              if (_param->_have_port_depth[context])
+                {
+                  TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                }
+                  TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+            }
+        }
+        LABEL("BRANCH_COMPLETE - hit ifetch");
+        {
+          uint32_t port = rand() % _param->_nb_inst_branch_complete;
+            {
+              uint32_t i=0;
+              bool find = false;
+              do
+                {
+                  in_BRANCH_COMPLETE_VAL                  [port]->write((rand()%100)<percent_transaction_branch_complete);
+                  in_BRANCH_COMPLETE_CONTEXT_ID           [port]->write(context);
+                  in_BRANCH_COMPLETE_DEPTH                [port]->write(i);
+                  in_BRANCH_COMPLETE_ADDRESS              [port]->write(0xcacacaca+i);
+                  in_BRANCH_COMPLETE_FLAG                 [port]->write(0);
+                  if (_param->_have_port_depth[context])
+                    {
+                      TEST(Tdepth_t,out_DEPTH_TAIL     [context]->read(), 0);
+                    }
+                      TEST(Tdepth_t,out_DEPTH_NB_BRANCH[context]->read(), _param->_size_queue[context]);
+                  SC_START(0);
+                  LABEL("BRANCH_COMPLETE [%d] %d - %d.",port,in_BRANCH_COMPLETE_VAL [port]->read(),out_BRANCH_COMPLETE_ACK [port]->read());
+                  if (in_BRANCH_COMPLETE_VAL [port]->read() and out_BRANCH_COMPLETE_ACK [port]->read())
+                    {
+                      LABEL("BRANCH_COMPLETE [%d] - Transaction accepted",port);
+                      find = true;
+                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_MISS_PREDICTION[port]->read(),1);
+                      TEST(Tcontrol_t,out_BRANCH_COMPLETE_TAKE           [port]->read(),0);
+                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_SRC    [port]->read(),0xdeadbeef+i);
+                      TEST(Taddress_t,out_BRANCH_COMPLETE_ADDRESS_DEST   [port]->read(),0x21071981+i);
+                    }
+                  SC_START(1);
+                } while (not find);
+              in_BRANCH_COMPLETE_VAL              [port]->write(0);
+            }
+        }
+        LABEL("UPDATE - miss ifetch");
+        {
+          uint32_t port = 0; //rand() % _param->_nb_inst_update;
+//        for (uint32_t i=0; i<_param->_size_queue[context]; i++)
+            {
+              uint32_t i=0;
+              bool find = false;
+              do
+                {
+                  in_UPDATE_ACK [port]->write((rand()%100)<percent_transaction_update);
+                  SC_START(0);
+                  if (out_UPDATE_VAL [port]->read() and in_UPDATE_ACK [port]->read())
+                    {
+                      LABEL("UPDATE [%d] - Transaction accepted",port);
+                      find = true;
+                      TEST(Tcontext_t         ,out_UPDATE_CONTEXT_ID            [port]->read(), context);
+                      TEST(Tcontrol_t         ,out_UPDATE_MISS_PREDICTION       [port]->read(), 1);
+                      TEST(Tcontrol_t         ,out_UPDATE_DIRECTION_GOOD        [port]->read(), 0);
+                      TEST(Tcontrol_t         ,out_UPDATE_BTB_VAL               [port]->read(), 1);
+                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_SRC       [port]->read(), 0xdeadbeef+i);
+                      TEST(Taddress_t         ,out_UPDATE_BTB_ADDRESS_DEST      [port]->read(), 0x21071981+i);
+                      TEST(Tbranch_condition_t,out_UPDATE_BTB_CONDITION         [port]->read(), BRANCH_CONDITION_FLAG_SET);
+                      TEST(Tcontrol_t         ,out_UPDATE_DIR_VAL               [port]->read(), 1);
+                      if (_param->_have_port_history)
+                        TEST(Thistory_t         ,out_UPDATE_DIR_HISTORY           [port]->read(), i);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_VAL               [port]->read(), 0);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PUSH              [port]->read(), 0);
+                      TEST(Taddress_t         ,out_UPDATE_RAS_ADDRESS           [port]->read(), 0xdeaddead+i);
+                      TEST(Tptr_t             ,out_UPDATE_RAS_INDEX             [port]->read(), (0x12345678+i)%_param->_size_ras_index[context]);
+                      TEST(Tcontrol_t         ,out_UPDATE_RAS_PREDICTION_IFETCH [port]->read(), 1);
+                    }
+                  SC_START(1);
+                } while (not find);
+              in_UPDATE_ACK              [port]->write(0);
+            }
+            LABEL("Wait a moment");
+            SC_START(_param->_size_queue[context]);
+            // wait the garbage collector
+            while (((not (_param->_have_port_depth[context])) or (out_DEPTH_TAIL     [context]->read() != 0)) and
+                   (out_DEPTH_NB_BRANCH[context]->read() != 0))
+                {
+                  LABEL("DEPTH [%d] nb_branch : %d - tail : %d",context,out_DEPTH_NB_BRANCH[context]->read(), out_DEPTH_TAIL [context]->read());
+                  SC_START(1);
+                }
+        }
+      }
+      LABEL ("Yo1");
+      SC_START(1);
+      LABEL ("Yo2");
+    }
+    }// ITERATION
   /********************************************************
 …
   delete []  in_PREDICT_RAS_ADDRESS         ;
   delete []  in_PREDICT_RAS_INDEX           ;
 //delete [] out_PREDICT_UPDATE_PREDICTION_ID;
+  delete [] out_PREDICT_UPDATE_PREDICTION_ID;
   // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   delete []  in_DECOD_UPDATE_PREDICTION_ID  ;
 //delete [] out_DECOD_DEPTH                 ;
+  delete []  in_DECOD_IS_ACCURATE           ;
   // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  delete [] out_DEPTH_NB_BRANCH;
+  delete [] out_DEPTH_TAIL;
+  delete [] out_DEPTH_CURRENT;
+  delete [] out_DEPTH_MIN;
+  delete [] out_DEPTH_MAX;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Parameters.h

-              r82
+              r88
+  {
     //-----[ fields ]------------------------------------------------------------
+  public : uint32_t   _nb_context             ;
+  public : uint32_t * _size_queue             ; // [nb_context]
+  public : uint32_t   _size_address           ;
+  public : uint32_t   _nb_inst_predict        ;
+  public : uint32_t   _nb_inst_decod          ;
+  public : uint32_t   _nb_inst_branch_complete;
+  public : uint32_t   _nb_inst_update         ;
+  public : uint32_t   _size_history           ;
+  public : uint32_t * _size_ras_index         ; // [nb_context]
+  public : uint32_t   _nb_context                ;
+  public : uint32_t * _size_upt_queue            ; // [nb_context]
+  public : uint32_t * _size_ufpt_queue           ; // [nb_context]
+//public : uint32_t   _size_address              ;
+  public : uint32_t   _nb_inst_predict           ;
+  public : uint32_t   _nb_inst_decod             ;
+  public : uint32_t   _nb_inst_branch_complete   ;
+  public : uint32_t   _nb_inst_update            ;
+  public : uint32_t   _size_history              ;
+  public : uint32_t * _size_ras_index            ; // [nb_context]
+  public : const bool _not_accurate_block_predict;
   public : uint32_t   _size_context_id        ;
   public : uint32_t * _size_depth             ; // [nb_context]
   public : uint32_t   _max_size_depth         ;
   public : uint32_t   _max_size_ras_index     ;
   public : bool       _have_port_context_id   ;
   public : bool     * _have_port_depth        ; // [nb_context]
   public : bool       _have_port_max_depth    ;
   public : bool       _have_port_history      ;
+//public : uint32_t   _size_context_id           ;
+//public : uint32_t * _size_depth                ; // [nb_context]
+//public : uint32_t   _max_size_depth            ;
+  public : uint32_t   _max_size_ras_index        ;
+//public : bool       _have_port_context_id      ;
+//public : bool     * _have_port_depth           ; // [nb_context]
+//public : bool       _have_port_max_depth       ;
+  public : bool       _have_port_history         ;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t   nb_context             ,
+                        uint32_t * size_queue             ,
+                        uint32_t * size_upt_queue         ,
+                        uint32_t * size_ufpt_queue        ,
                         uint32_t   size_address           ,
                         uint32_t   nb_inst_predict        ,
 …
                         uint32_t   nb_inst_update         ,
                         uint32_t   size_history           ,
+                        uint32_t * size_ras_index         );
+                        uint32_t * size_ras_index         ,
+                        bool       is_toplevel=false);
 //public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Types.h

-              r82
+              r88
   typedef enum
+    {
+      UPDATE_PREDICTION_STATE_EMPTY      , // Slot is empty
+      UPDATE_PREDICTION_STATE_WAIT_DECOD , // Fetch have access at the predictor
+      UPDATE_PREDICTION_STATE_WAITEND    , // Have make a prediction, wait branch_complete
+      UPDATE_PREDICTION_STATE_EVENT      , // have a event - must signal at the context_unit
+      UPDATE_PREDICTION_STATE_OK         , // branch is complete and can update predictor
+      UPDATE_PREDICTION_STATE_KO         , // have a event - must update predictor unit
+      UPDATE_PREDICTION_STATE_END          // branch is updated
+    } state_t;
+      EVENT_STATE_OK                 , // Can predict
+      EVENT_STATE_FLUSH_UFPT         , // in decod  stage, detect a miss, continue to execute but flush ufpt
+      EVENT_STATE_FLUSH_UFPT_AND_UPT , // in commit stage, detect a miss, stop context and flush ufpt and upt
+      EVENT_STATE_FLUSH_UPT_RAS      , // in commit stage, detect a miss, context is stop and ufpt is flush, update RAS
+      EVENT_STATE_FLUSH_UPT          , // in commit stage, detect a miss, context is stop and ufpt is flush
+      EVENT_STATE_UPDATE_CONTEXT       // prediction unit is update, send signal to context manager
+    } event_state_t;
+  class entry_t
+  typedef enum
+    {
+      UPDATE_FETCH_PREDICTION_STATE_EMPTY       , // Slot is empty
+      UPDATE_FETCH_PREDICTION_STATE_WAIT_DECOD  , // Have make a prediction, wait decod
+      UPDATE_FETCH_PREDICTION_STATE_EVENT       , // previous branch is a miss prediction
+      UPDATE_FETCH_PREDICTION_STATE_END           // branch is updated
+    } ufpt_state_t;
+  typedef enum
+    {
+      UPDATE_PREDICTION_STATE_EMPTY             , // Slot is empty
+      UPDATE_PREDICTION_STATE_WAIT_END          , // Have make a prediction, wait branch_complete
+      UPDATE_PREDICTION_STATE_OK                , // this branch is a hit prediction
+      UPDATE_PREDICTION_STATE_KO                , // this branch is a miss prediction
+      UPDATE_PREDICTION_STATE_EVENT             , // previous branch is a miss prediction
+      UPDATE_PREDICTION_STATE_END                 // branch is updated
+    } upt_state_t;
+  class ufpt_entry_t
+  {
+  public : state_t             _state;
+  public : Tcontrol_t          _ifetch_prediction;
+  public : Tbranch_condition_t _condition;
+  public : Taddress_t          _address_src;
+  public : Taddress_t          _address_dest;
+  public : Tcontrol_t          _last_take;
+  public : Tcontrol_t          _good_take;
+  public : Thistory_t          _history;
+  public : Taddress_t          _address_ras;
+  public : Tptr_t              _index_ras;
+  public : ufpt_state_t        _state            ;
+  public : Tbranch_condition_t _condition        ;
+  public : Taddress_t          _address_src      ;
+  public : Taddress_t          _address_dest     ;
+  public : Tcontrol_t          _last_take        ;
+//public : Tcontrol_t          _good_take        ;
+  public : Tcontrol_t          _is_accurate      ;
+  public : Thistory_t          _history          ;
+  public : Taddress_t          _address_ras      ;
+  public : Tptr_t              _index_ras        ;
+//public : Tcontrol_t          _ifetch_prediction;
   };
+  class upt_entry_t
+  {
+  public : upt_state_t         _state            ;
+  public : Tbranch_condition_t _condition        ;
+  public : Taddress_t          _address_src      ;
+  public : Taddress_t          _address_dest     ;
+  public : Tcontrol_t          _last_take        ;
+  public : Tcontrol_t          _good_take        ; // not in ufpt
+  public : Tcontrol_t          _is_accurate      ;
+  public : Thistory_t          _history          ;
+  public : Taddress_t          _address_ras      ;
+  public : Tptr_t              _index_ras        ;
+  public : Tcontrol_t          _ifetch_prediction; // not in ufpt
+  };
+// BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK
+// BRANCH_CONDITION_NONE_WITH_WRITE_STACK
+// BRANCH_CONDITION_FLAG_UNSET
+// BRANCH_CONDITION_FLAG_SET
+// BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK
+// BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK
+// BRANCH_CONDITION_READ_STACK
+#define update_btb(cond)  true
+#define update_dir(cond)  ((cond == BRANCH_CONDITION_FLAG_UNSET) or \
+                           (cond == BRANCH_CONDITION_FLAG_SET))
+#define update_ras(cond)  ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK         ) or \
+                           (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or \
+                           (cond == BRANCH_CONDITION_READ_STACK                    ))
+#define push_ras(cond)    ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK         ) or \
+                           (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK))
+#define pop_ras(cond)     ((cond == BRANCH_CONDITION_READ_STACK                    ))
+#define need_update(cond) update_ras(cond)
 }; // end namespace update_prediction_table
 …
 }; // end namespace behavioural
+  template<> inline std::string toString<morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::event_state_t>(const morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::event_state_t& x)
+  {
+    switch (x)
+      {
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_OK                   : return "ok"                  ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UFPT           : return "flush_ufpt"          ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UFPT_AND_UPT   : return "flush_ufpt_and_upt"  ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UPT_RAS        : return "flush_upt_ras"       ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_FLUSH_UPT            : return "flush_upt"           ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::EVENT_STATE_UPDATE_CONTEXT       : return "update_context"      ; break;
+      default    : return ""      ; break;
+      }
+  };
+  template<> inline std::string toString<morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::state_t>(const morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::state_t& x)
+  template<> inline std::string toString<morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::ufpt_state_t>(const morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::ufpt_state_t& x)
+  {
+    switch (x)
+      {
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_FETCH_PREDICTION_STATE_EMPTY      : return "empty"     ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_FETCH_PREDICTION_STATE_WAIT_DECOD : return "wait_decod"; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_FETCH_PREDICTION_STATE_EVENT      : return "event"     ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_FETCH_PREDICTION_STATE_END        : return "end"       ; break;
+      default    : return ""      ; break;
+      }
+  };
+  template<> inline std::string toString<morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::upt_state_t>(const morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::upt_state_t& x)
+  {
     switch (x)
+      {
       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_EMPTY      : return "empty"     ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_WAIT_DECOD : return "wait_decod"; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_WAITEND    : return "waitend"   ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_EVENT      : return "event"     ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_WAIT_END   : return "wait_end"  ; break;
       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_OK         : return "ok"        ; break;
       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_KO         : return "ko"        ; break;
+      case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_EVENT      : return "event"     ; break;
       case morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::update_prediction_table::UPDATE_PREDICTION_STATE_END        : return "end"       ; break;
       default    : return ""      ; break;
 …
   };
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Update_Prediction_Table.h

-              r82
+              r88
 #ifdef STATISTICS
   public    : Stat                           * _stat;
+  private   : counter_t                     ** _stat_nb_branch_hit       ; //[nb_context]
+  private   : counter_t                     ** _stat_nb_branch_miss      ; //[nb_context]
+  private   : counter_t                     ** _stat_nb_branch_unused    ; //[nb_context]
+  private   : counter_t                     ** _stat_queue_nb_cycle_empty; //[nb_context]
+  private   : counter_t                     ** _stat_queue_nb_cycle_full ; //[nb_context]
+  private   : counter_t                     ** _stat_queue_nb_elt        ; //[nb_context]
 #endif
 …
     // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_CLOCK                      *  in_CLOCK        ;
   public    : SC_IN (Tcontrol_t)            *  in_NRESET       ;
+  public    : SC_CLOCK                      *  in_CLOCK                          ;
+  public    : SC_IN (Tcontrol_t)            *  in_NRESET                         ;
     // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_VAL                 ; //[nb_inst_predict]
   public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_ACK                 ; //[nb_inst_predict]
   public    : SC_IN (Tcontext_t         )  **  in_PREDICT_CONTEXT_ID          ; //[nb_inst_predict]
   public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_SRC     ; //[nb_inst_predict]
   public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_DEST    ; //[nb_inst_predict]
   public    : SC_IN (Tbranch_condition_t)  **  in_PREDICT_BTB_CONDITION       ; //[nb_inst_predict]
   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_LAST_TAKE       ; //[nb_inst_predict]
   public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_IS_ACCURATE     ; //[nb_inst_predict]
   public    : SC_IN (Thistory_t         )  **  in_PREDICT_DIR_HISTORY         ; //[nb_inst_predict]
   public    : SC_IN (Taddress_t         )  **  in_PREDICT_RAS_ADDRESS         ; //[nb_inst_predict]
   public    : SC_IN (Tptr_t             )  **  in_PREDICT_RAS_INDEX           ; //[nb_inst_predict]
 //public    : SC_OUT(Tprediction_ptr_t  )  ** out_PREDICT_UPDATE_PREDICTION_ID; //[nb_inst_predict]
+  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_VAL                    ; //[nb_inst_predict]
+  public    : SC_OUT(Tcontrol_t         )  ** out_PREDICT_ACK                    ; //[nb_inst_predict]
+  public    : SC_IN (Tcontext_t         )  **  in_PREDICT_CONTEXT_ID             ; //[nb_inst_predict]
+  public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_SRC        ; //[nb_inst_predict]
+  public    : SC_IN (Taddress_t         )  **  in_PREDICT_BTB_ADDRESS_DEST       ; //[nb_inst_predict]
+  public    : SC_IN (Tbranch_condition_t)  **  in_PREDICT_BTB_CONDITION          ; //[nb_inst_predict]
+  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_LAST_TAKE          ; //[nb_inst_predict]
+  public    : SC_IN (Tcontrol_t         )  **  in_PREDICT_BTB_IS_ACCURATE        ; //[nb_inst_predict]
+  public    : SC_IN (Thistory_t         )  **  in_PREDICT_DIR_HISTORY            ; //[nb_inst_predict]
+  public    : SC_IN (Taddress_t         )  **  in_PREDICT_RAS_ADDRESS            ; //[nb_inst_predict]
+  public    : SC_IN (Tptr_t             )  **  in_PREDICT_RAS_INDEX              ; //[nb_inst_predict]
+  public    : SC_OUT(Tprediction_ptr_t  )  ** out_PREDICT_UPDATE_PREDICTION_ID   ; //[nb_inst_predict]
     // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_VAL                   ; //[nb_inst_decod]
   public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_ACK                   ; //[nb_inst_decod]
   public    : SC_IN (Tcontext_t         )  **  in_DECOD_CONTEXT_ID            ; //[nb_inst_decod]
   public    : SC_IN (Taddress_t         )  **  in_DECOD_BTB_ADDRESS_SRC       ; //[nb_inst_decod]
   public    : SC_IN (Taddress_t         )  **  in_DECOD_BTB_ADDRESS_DEST      ; //[nb_inst_decod]
   public    : SC_IN (Tbranch_condition_t)  **  in_DECOD_BTB_CONDITION         ; //[nb_inst_decod]
   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_BTB_LAST_TAKE         ; //[nb_inst_decod]
 //public    : SC_IN (Tcontrol_t         )  **  in_DECOD_BTB_IS_ACCURATE       ; //[nb_inst_decod]
+//public    : SC_IN (Thistory_t         )  **  in_DECOD_DIR_HISTORY           ; //[nb_inst_decod] // if ifetch prediction is miss -> miss btb -> make a static state
   public    : SC_IN (Taddress_t         )  **  in_DECOD_RAS_ADDRESS           ; //[nb_inst_decod]
   public    : SC_IN (Tptr_t             )  **  in_DECOD_RAS_INDEX             ; //[nb_inst_decod]
   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_MISS_IFETCH           ; //[nb_inst_decod]
   public    : SC_IN (Tcontrol_t         )  **  in_DECOD_MISS_DECOD            ; //[nb_inst_decod]
   public    : SC_IN (Tprediction_ptr_t  )  **  in_DECOD_UPDATE_PREDICTION_ID  ; //[nb_inst_decod]
 //public    : SC_OUT(Tdepth_t           )  ** out_DECOD_DEPTH                 ; //[nb_inst_decod]
+  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_VAL                      ; //[nb_inst_decod]
+  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_ACK                      ; //[nb_inst_decod]
+  public    : SC_IN (Tcontext_t         )  **  in_DECOD_CONTEXT_ID               ; //[nb_inst_decod]
+  public    : SC_IN (Taddress_t         )  **  in_DECOD_BTB_ADDRESS_SRC          ; //[nb_inst_decod]
+  public    : SC_IN (Taddress_t         )  **  in_DECOD_BTB_ADDRESS_DEST         ; //[nb_inst_decod]
+  public    : SC_IN (Tbranch_condition_t)  **  in_DECOD_BTB_CONDITION            ; //[nb_inst_decod]
+  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_BTB_LAST_TAKE            ; //[nb_inst_decod]
+//public    : SC_IN (Thistory_t         )  **  in_DECOD_DIR_HISTORY              ; //[nb_inst_decod] // if ifetch prediction is miss -> miss btb -> make a static state
+  public    : SC_IN (Taddress_t         )  **  in_DECOD_RAS_ADDRESS              ; //[nb_inst_decod]
+  public    : SC_IN (Tptr_t             )  **  in_DECOD_RAS_INDEX                ; //[nb_inst_decod]
+  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_MISS_IFETCH              ; //[nb_inst_decod]
+  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_MISS_DECOD               ; //[nb_inst_decod]
+  public    : SC_IN (Tprediction_ptr_t  )  **  in_DECOD_UPDATE_PREDICTION_ID     ; //[nb_inst_decod]
+//public    : SC_OUT(Tdepth_t           )  ** out_DECOD_DEPTH                    ; //[nb_inst_decod]
+  public    : SC_IN (Tcontrol_t         )  **  in_DECOD_IS_ACCURATE              ; //[nb_inst_decod]
     // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
     // ~~~~~[ Interface : "branch_event" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_VAL            ; //[nb_context]
   public    : SC_IN (Tcontrol_t         )  **  in_BRANCH_EVENT_ACK            ; //[nb_context]
 //public    : SC_OUT(Tcontext_t         )  ** out_BRANCH_EVENT_CONTEXT_ID     ; //[nb_context]
 //public    : SC_OUT(Tdepth_t           )  ** out_BRANCH_EVENT_DEPTH          ; //[nb_context]
 //public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_MISS_PREDICTION; //[nb_context] is always miss prediction
   public    : SC_OUT(Taddress_t         )  ** out_BRANCH_EVENT_ADDRESS_SRC    ; //[nb_context]
   public    : SC_OUT(Taddress_t         )  ** out_BRANCH_EVENT_ADDRESS_DEST   ; //[nb_context]
+  public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_VAL               ; //[nb_context]
+  public    : SC_IN (Tcontrol_t         )  **  in_BRANCH_EVENT_ACK               ; //[nb_context]
+//public    : SC_OUT(Tcontext_t         )  ** out_BRANCH_EVENT_CONTEXT_ID        ; //[nb_context]
+//public    : SC_OUT(Tdepth_t           )  ** out_BRANCH_EVENT_DEPTH             ; //[nb_context]
+//public    : SC_OUT(Tcontrol_t         )  ** out_BRANCH_EVENT_MISS_PREDICTION   ; //[nb_context] is always miss prediction
+  public    : SC_OUT(Taddress_t         )  ** out_BRANCH_EVENT_ADDRESS_SRC       ; //[nb_context]
+  public    : SC_OUT(Taddress_t         )  ** out_BRANCH_EVENT_ADDRESS_DEST      ; //[nb_context]
     // ~~~~~[ Interface : "update" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_VAL                  ; //[nb_inst_update]
   public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_ACK                  ; //[nb_inst_update]
   public    : SC_OUT(Tcontext_t         )  ** out_UPDATE_CONTEXT_ID           ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_MISS_PREDICTION      ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_DIRECTION_GOOD       ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_VAL              ; //[nb_inst_update]
   public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_SRC      ; //[nb_inst_update]
   public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_DEST     ; //[nb_inst_update]
   public    : SC_OUT(Tbranch_condition_t)  ** out_UPDATE_BTB_CONDITION        ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_DIR_VAL              ; //[nb_inst_update]
   public    : SC_OUT(Thistory_t         )  ** out_UPDATE_DIR_HISTORY          ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_VAL              ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_PUSH             ; //[nb_inst_update]
   public    : SC_OUT(Taddress_t         )  ** out_UPDATE_RAS_ADDRESS          ; //[nb_inst_update]
   public    : SC_OUT(Tptr_t             )  ** out_UPDATE_RAS_INDEX            ; //[nb_inst_update]
   public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_PREDICTION_IFETCH; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_VAL                     ; //[nb_inst_update]
+  public    : SC_IN (Tcontrol_t         )  **  in_UPDATE_ACK                     ; //[nb_inst_update]
+  public    : SC_OUT(Tcontext_t         )  ** out_UPDATE_CONTEXT_ID              ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_MISS_PREDICTION         ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_DIRECTION_GOOD          ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_BTB_VAL                 ; //[nb_inst_update]
+  public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_SRC         ; //[nb_inst_update]
+  public    : SC_OUT(Taddress_t         )  ** out_UPDATE_BTB_ADDRESS_DEST        ; //[nb_inst_update]
+  public    : SC_OUT(Tbranch_condition_t)  ** out_UPDATE_BTB_CONDITION           ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_DIR_VAL                 ; //[nb_inst_update]
+  public    : SC_OUT(Thistory_t         )  ** out_UPDATE_DIR_HISTORY             ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_VAL                 ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_PUSH                ; //[nb_inst_update]
+  public    : SC_OUT(Taddress_t         )  ** out_UPDATE_RAS_ADDRESS             ; //[nb_inst_update]
+  public    : SC_OUT(Tptr_t             )  ** out_UPDATE_RAS_INDEX               ; //[nb_inst_update]
+  public    : SC_OUT(Tcontrol_t         )  ** out_UPDATE_RAS_PREDICTION_IFETCH   ; //[nb_inst_update]
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_NB_BRANCH; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_TAIL; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_CURRENT                  ; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_MIN                      ; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_MAX                      ; //[nb_context]
+    // If DEPTH_CURRENT :
+    // equal at     DEPTH_MIN            -> not speculative
+    // not include ]DEPTH_MIN:DEPTH_MAX[ -> previous branch miss
+    //     include ]DEPTH_MIN:DEPTH_MAX[ -> speculative
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  private   : uint32_t                      * reg_TOP                    ; //[nb_context]
+  private   : uint32_t                      * reg_BOTTOM                 ; //[nb_context]
+  private   : uint32_t                      * reg_NB_ELT                 ; //[nb_context]
+  private   : uint32_t                      * reg_NB_ELT_UPDATE          ; //[nb_context]
+  private   : uint32_t                      * reg_NB_ELT_NEED_UPDATE     ; //[nb_context]
+  private   : entry_t                      ** reg_UPDATE_PREDICTION_TABLE; //[nb_context][size_queue]
+  private   : uint32_t                        reg_UPDATE_PRIORITY        ;
+  private   : uint32_t                        reg_UPDATE_PRIORITY                ;
+  private   : ufpt_entry_t                 ** reg_UPDATE_FETCH_PREDICTION_TABLE  ; //[nb_context][size_ufpt_queue]
+  private   : uint32_t                      * reg_UFPT_BOTTOM                    ; //[nb_context]
+  private   : uint32_t                      * reg_UFPT_TOP                       ; //[nb_context]
+  private   : uint32_t                      * reg_UFPT_UPDATE                    ; //[nb_context]
+  private   : uint32_t                      * reg_UFPT_NB_NEED_UPDATE            ; //[nb_context]
+  private   : upt_entry_t                  ** reg_UPDATE_PREDICTION_TABLE        ; //[nb_context][size_upt_queue]
+  private   : uint32_t                      * reg_UPT_BOTTOM                     ; //[nb_context]
+  private   : uint32_t                      * reg_UPT_TOP                        ; //[nb_context]
+  private   : uint32_t                      * reg_UPT_UPDATE                     ; //[nb_context]
+  private   : uint32_t                      * reg_UPT_NB_NEED_UPDATE             ; //[nb_context]
+  private   : bool                          * reg_IS_ACCURATE                    ; //[nb_context]
+  private   : event_state_t                 * reg_EVENT_STATE                    ; //[nb_context]
+  private   : Tcontrol_t                    * reg_EVENT_RAS_CORRUPTED            ; //[nb_context] // RAS must be flush
+  private   : Taddress_t                    * reg_EVENT_ADDRESS_SRC              ; //[nb_context] // Address branch
+  private   : Tcontrol_t                    * reg_EVENT_ADDRESS_SRC_VAL          ; //[nb_context] // if miss ifetch, decod issue branch, dest must be reload
+  private   : Taddress_t                    * reg_EVENT_ADDRESS_DEST             ; //[nb_context] // Address dest
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   private   : Tcontrol_t                    * internal_PREDICT_ACK                    ; //[nb_inst_predict]
+  private   : Tdepth_t                      * internal_PREDICT_UPDATE_PREDICTION_ID   ; //[nb_inst_predict]
   private   : Tcontrol_t                    * internal_DECOD_ACK                      ; //[nb_inst_decod]
+  private   : uint32_t                      * internal_DECOD_UPT_PTR_WRITE            ; //[nb_inst_decod]
   private   : Tcontrol_t                    * internal_BRANCH_COMPLETE_ACK            ; //[nb_inst_branch_complete]
   private   : Tcontrol_t                    * internal_BRANCH_COMPLETE_MISS_PREDICTION; //[nb_inst_branch_complete]
 …
   private   : Tdepth_t                      * internal_BRANCH_EVENT_DEPTH             ; //[nb_context]
   private   : Tcontrol_t                    * internal_UPDATE_VAL                     ; //[nb_inst_update]
+  private   : Tcontrol_t                    * internal_UPDATE_VAL_WITHOUT_ACK         ; //[nb_inst_update]
   private   : Tcontext_t                    * internal_UPDATE_CONTEXT_ID              ; //[nb_inst_update]
+  private   : bool                          * internal_UPDATE_FROM_UFPT               ; //[nb_inst_update]
   private   : Tdepth_t                      * internal_UPDATE_DEPTH                   ; //[nb_inst_update]
+  private   : bool                          * internal_UPDATE_RAS                     ; //[nb_inst_update]
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Parameters.cpp

-              r82
+              r88
 #define FUNCTION "Update_Prediction_Table::Parameters"
   Parameters::Parameters (uint32_t   nb_context             ,
+                          uint32_t * size_queue             ,
+                          uint32_t * size_upt_queue         ,
+                          uint32_t * size_ufpt_queue        ,
                           uint32_t   size_address           ,
                           uint32_t   nb_inst_predict        ,
 …
                           uint32_t   nb_inst_update         ,
                           uint32_t   size_history           ,
+                          uint32_t * size_ras_index         )
+                          uint32_t * size_ras_index         ,
+                          bool       is_toplevel):
+    _not_accurate_block_predict (false)
+  {
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
     _nb_context              = nb_context             ;
+    _size_queue              = size_queue             ;
+    _size_address            = size_address           ;
+    _size_upt_queue          = size_upt_queue         ;
+    _size_ufpt_queue         = size_ufpt_queue        ;
+//  _size_address            = size_address           ;
     _nb_inst_predict         = nb_inst_predict        ;
     _nb_inst_decod           = nb_inst_decod          ;
 …
     _size_ras_index          = size_ras_index         ;
-    _size_context_id         = log2(nb_context);
-    _size_depth              = new uint32_t[_nb_context];
-    _have_port_depth         = new bool    [_nb_context];
-    for (uint32_t i=0; i<_nb_context; i++)
+      {
-        _size_depth      [i] = log2(_size_queue[i]);
-        _have_port_depth [i] = (_size_depth [i] > 0);
+      }
-    _max_size_depth          = max<uint32_t>(_size_depth,_nb_context);
     _max_size_ras_index      = max<uint32_t>(_size_ras_index,nb_context);
-    _have_port_context_id    = _size_context_id> 0;
-    _have_port_max_depth     = _max_size_depth > 0;
     _have_port_history       = _size_history   > 0;
+    test();
+    if (is_toplevel)
+      {
+        _size_instruction_address = size_address;
+        _size_context_id          = log2(nb_context);
+        _size_depth               = log2(max<uint32_t>(_size_upt_queue,_nb_context));
+        _have_port_context_id    = _size_context_id> 0;
+        _have_port_depth          = _size_depth > 0;
+        copy ();
+      }
-    test();
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
   };
 …
+  {
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+    delete [] _size_depth     ;
+    delete [] _have_port_depth;
+//     delete [] _size_depth     ;
+//     delete [] _have_port_depth;
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Update_Prediction_Table::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Parameters_msg_error.cpp

-              r82
+              r88
 #include "Behavioural/include/Types.h"
 #include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Parameters.h"
+#include "Common/include/Max.h"
 #include <sstream>
 …
     Parameters_test test ("Update_Prediction_Table");
+    if (morpheo::behavioural::test<Tdepth_t>(_max_size_depth) == false)
+      test.error("type \"Tdepth_t\" is too small.");
+    for (uint32_t i=0; i<_nb_context; i++)
+      if (_size_ufpt_queue [i] > _size_upt_queue [i])
+        test.error(toString(_("context \"%d\" : size_upt_queue must be >= at size_ufpt_queue\n"),i));
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Parameters_print.cpp

-              r81
+              r88
     xml.balise_open("update_prediction_table");
     xml.singleton_begin("nb_context             "); xml.attribut("value",toString(_nb_context             )); xml.singleton_end();
     xml.singleton_begin("size_address           "); xml.attribut("value",toString(_size_address           )); xml.singleton_end();
+//  xml.singleton_begin("size_address           "); xml.attribut("value",toString(_size_address           )); xml.singleton_end();
     xml.singleton_begin("nb_inst_predict        "); xml.attribut("value",toString(_nb_inst_predict        )); xml.singleton_end();
     xml.singleton_begin("nb_inst_decod          "); xml.attribut("value",toString(_nb_inst_decod          )); xml.singleton_end();
 …
         xml.  attribut("id"  ,toString(i));
         xml. balise_open_end();
+        xml.  singleton_begin("size_queue             "); xml.attribut("value",toString(_size_queue             [i])); xml.singleton_end();
+        xml.  singleton_begin("size_upt_queue         "); xml.attribut("value",toString(_size_upt_queue         [i])); xml.singleton_end();
+        xml.  singleton_begin("size_ufpt_queue        "); xml.attribut("value",toString(_size_ufpt_queue        [i])); xml.singleton_end();
         xml.  singleton_begin("size_ras_index         "); xml.attribut("value",toString(_size_ras_index         [i])); xml.singleton_end();
         xml. balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table.cpp

-              r82
+              r88
     usage_environment(_usage);
+#if DEBUG_Update_Prediction_Table == true
+    log_printf(INFO,Update_Prediction_Table,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Update_Prediction_Table,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Update_Prediction_Table,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 …
         SC_METHOD (genMoore);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // use internal register
 # ifdef SYSTEMCASS_SPECIFIC
 …
             if (_param->_have_port_context_id)
               sensitive << (*(in_PREDICT_CONTEXT_ID [i]));
             sensitive << (*(in_PREDICT_BTB_IS_ACCURATE [i]));
+//          sensitive << (*(in_PREDICT_BTB_IS_ACCURATE [i]));
+          }
 …
             if (_param->_have_port_context_id)
               sensitive << (*(in_DECOD_CONTEXT_ID [i]));
-            sensitive << (*(in_DECOD_MISS_IFETCH [i]))
-                      << (*(in_DECOD_MISS_DECOD  [i]));
+          }
 …
         for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+          {
-            (*(out_DECOD_ACK                  [i])) (*(in_DECOD_MISS_IFETCH [i]));
-            (*(out_DECOD_ACK                  [i])) (*(in_DECOD_MISS_DECOD  [i]));
             if (_param->_have_port_context_id)
             (*(out_DECOD_ACK                  [i])) (*(in_DECOD_CONTEXT_ID  [i]));
 …
             if (_param->_have_port_context_id)
             sensitive << (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
             if (_param->_have_port_max_depth)
+            if (_param->_have_port_depth)
             sensitive << (*(in_BRANCH_COMPLETE_DEPTH [i]));
             sensitive << (*(in_BRANCH_COMPLETE_FLAG    [i]))
 …
             if (_param->_have_port_context_id)
             (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
             if (_param->_have_port_max_depth)
+            if (_param->_have_port_depth)
             (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
             (*(out_BRANCH_COMPLETE_MISS_PREDICTION [i])) (*(in_BRANCH_COMPLETE_FLAG       [i]));
 …
             if (_param->_have_port_context_id)
             (*(out_BRANCH_COMPLETE_TAKE            [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
             if (_param->_have_port_max_depth)
+            if (_param->_have_port_depth)
             (*(out_BRANCH_COMPLETE_TAKE            [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
             (*(out_BRANCH_COMPLETE_TAKE            [i])) (*(in_BRANCH_COMPLETE_FLAG       [i]));
 …
             if (_param->_have_port_context_id)
             (*(out_BRANCH_COMPLETE_ADDRESS_SRC     [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
             if (_param->_have_port_max_depth)
+            if (_param->_have_port_depth)
             (*(out_BRANCH_COMPLETE_ADDRESS_SRC     [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
             if (_param->_have_port_context_id)
             (*(out_BRANCH_COMPLETE_ADDRESS_DEST    [i])) (*(in_BRANCH_COMPLETE_CONTEXT_ID [i]));
             if (_param->_have_port_max_depth)
+            if (_param->_have_port_depth)
             (*(out_BRANCH_COMPLETE_ADDRESS_DEST    [i])) (*(in_BRANCH_COMPLETE_DEPTH      [i]));
             (*(out_BRANCH_COMPLETE_ADDRESS_DEST    [i])) (*(in_BRANCH_COMPLETE_ADDRESS    [i]));
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_allocation.cpp

-              r82
+              r88
       ALLOC1_VALACK_OUT(out_PREDICT_ACK                 ,ACK);
       ALLOC1_SIGNAL_IN ( in_PREDICT_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_PREDICT_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
       ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_BTB_IS_ACCURATE     ,"btb_is_accurate"     ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_PREDICT_DIR_HISTORY         ,"dir_history"         ,Thistory_t         ,_param->_size_history);
       ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_PREDICT_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_max_size_ras_index);
-//       ALLOC1_SIGNAL_OUT(out_PREDICT_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+    }
     // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC1_INTERFACE("decod", IN,SOUTH, "decod", _param->_nb_inst_predict);
+      ALLOC1_INTERFACE("decod", IN,SOUTH, "decod", _param->_nb_inst_decod);
       ALLOC1_VALACK_IN ( in_DECOD_VAL                 ,VAL);
       ALLOC1_VALACK_OUT(out_DECOD_ACK                 ,ACK);
       ALLOC1_SIGNAL_IN ( in_DECOD_CONTEXT_ID          ,"context_id"          ,Tcontext_t         ,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_DECOD_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_BTB_ADDRESS_SRC     ,"btb_address_src"     ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_BTB_ADDRESS_DEST    ,"btb_address_dest"    ,Taddress_t         ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_BTB_CONDITION       ,"btb_condition"       ,Tbranch_condition_t,_param->_size_branch_condition);
       ALLOC1_SIGNAL_IN ( in_DECOD_BTB_LAST_TAKE       ,"btb_last_take"       ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_DECOD_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_DECOD_RAS_ADDRESS         ,"ras_address"         ,Taddress_t         ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_DECOD_RAS_INDEX           ,"ras_index"           ,Tptr_t             ,_param->_max_size_ras_index);
       ALLOC1_SIGNAL_IN ( in_DECOD_MISS_IFETCH         ,"miss_ifetch"         ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_DECOD_MISS_DECOD          ,"miss_decod"          ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_IN ( in_DECOD_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_max_size_depth);
+      ALLOC1_SIGNAL_IN ( in_DECOD_UPDATE_PREDICTION_ID,"update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
 //    ALLOC1_SIGNAL_OUT(out_DECOD_DEPTH               ,"depth"               ,Tdepth_t           ,_param->_size_depth);
+      ALLOC1_SIGNAL_IN ( in_DECOD_IS_ACCURATE         ,"is_accurate"         ,Tcontrol_t         ,1);
+    }
 …
       ALLOC1_VALACK_OUT(out_BRANCH_COMPLETE_ACK            ,ACK);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_max_size_depth);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS        ,"address"        ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_size_depth);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS        ,"address"        ,Taddress_t,_param->_size_instruction_address);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_FLAG           ,"flag"           ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_TAKE           ,"take"           ,Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_ADDRESS_DEST   ,"address_dest"   ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_COMPLETE_ADDRESS_DEST   ,"address_dest"   ,Taddress_t,_param->_size_instruction_address);
+    }
 …
       ALLOC1_VALACK_IN ( in_BRANCH_EVENT_ACK            ,ACK);
 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_max_size_depth);
+//    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_size_depth);
 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_DEST   ,"address_dest"   ,Taddress_t,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_DEST   ,"address_dest"   ,Taddress_t,_param->_size_instruction_address);
+    }
 …
       ALLOC1_SIGNAL_OUT(out_UPDATE_DIRECTION_GOOD       ,"direction_good"       ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_VAL              ,"btb_val"              ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_SRC      ,"btb_address_src"      ,Taddress_t         ,_param->_size_address);
       ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_DEST     ,"btb_address_dest"     ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_SRC      ,"btb_address_src"      ,Taddress_t         ,_param->_size_instruction_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_ADDRESS_DEST     ,"btb_address_dest"     ,Taddress_t         ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_UPDATE_BTB_CONDITION        ,"btb_condition"        ,Tbranch_condition_t,_param->_size_branch_condition);
       ALLOC1_SIGNAL_OUT(out_UPDATE_DIR_VAL              ,"dir_val"              ,Tcontrol_t         ,1);
 …
       ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_VAL              ,"ras_val"              ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_PUSH             ,"ras_push"             ,Tcontrol_t         ,1);
       ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_ADDRESS          ,"ras_address"          ,Taddress_t         ,_param->_size_address);
+      ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_ADDRESS          ,"ras_address"          ,Taddress_t         ,_param->_size_instruction_address);
       ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_INDEX            ,"ras_index"            ,Tptr_t             ,_param->_max_size_ras_index);
       ALLOC1_SIGNAL_OUT(out_UPDATE_RAS_PREDICTION_IFETCH,"ras_prediction_ifetch",Tcontrol_t         ,1);
 …
+    {
       ALLOC1_INTERFACE("depth",OUT,SOUTH, "depth", _param->_nb_context);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_TAIL     ,"TAIL"     ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_NB_BRANCH,"NB_BRANCH",Tdepth_t,_param->_size_depth[alloc_signal_it1]+1);
+    }
+      ALLOC1_SIGNAL_OUT(out_DEPTH_CURRENT,"CURRENT",Tdepth_t,_param->_size_depth);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_MIN    ,"MIN"    ,Tdepth_t,_param->_size_depth);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_MAX    ,"MAX"    ,Tdepth_t,_param->_size_depth+1);
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    internal_PREDICT_ACK                     = new Tcontrol_t [_param->_nb_inst_predict];
+    internal_DECOD_ACK                       = new Tcontrol_t [_param->_nb_inst_decod];
+    internal_BRANCH_COMPLETE_ACK             = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_COMPLETE_MISS_PREDICTION = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_COMPLETE_TAKE            = new Tcontrol_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_COMPLETE_ADDRESS_DEST    = new Taddress_t [_param->_nb_inst_branch_complete];
+    internal_BRANCH_EVENT_VAL                = new Tcontrol_t [_param->_nb_context];
+    internal_BRANCH_EVENT_DEPTH              = new Tdepth_t   [_param->_nb_context];
+    internal_UPDATE_VAL                      = new Tcontrol_t [_param->_nb_inst_update];
+    internal_UPDATE_CONTEXT_ID               = new Tcontext_t [_param->_nb_inst_update];
+    internal_UPDATE_DEPTH                    = new Tdepth_t   [_param->_nb_inst_update];
+    ALLOC1(internal_PREDICT_ACK                     ,Tcontrol_t,_param->_nb_inst_predict);
+    ALLOC1(internal_PREDICT_UPDATE_PREDICTION_ID    ,Tdepth_t  ,_param->_nb_inst_predict);
+    ALLOC1(internal_DECOD_ACK                       ,Tcontrol_t,_param->_nb_inst_decod);
+    ALLOC1(internal_DECOD_UPT_PTR_WRITE             ,uint32_t  ,_param->_nb_inst_decod);
+    ALLOC1(internal_BRANCH_COMPLETE_ACK             ,Tcontrol_t,_param->_nb_inst_branch_complete);
+    ALLOC1(internal_BRANCH_COMPLETE_MISS_PREDICTION ,Tcontrol_t,_param->_nb_inst_branch_complete);
+    ALLOC1(internal_BRANCH_COMPLETE_TAKE            ,Tcontrol_t,_param->_nb_inst_branch_complete);
+    ALLOC1(internal_BRANCH_COMPLETE_ADDRESS_DEST    ,Taddress_t,_param->_nb_inst_branch_complete);
+    ALLOC1(internal_BRANCH_EVENT_VAL                ,Tcontrol_t,_param->_nb_context);
+    ALLOC1(internal_BRANCH_EVENT_DEPTH              ,Tdepth_t  ,_param->_nb_context);
+    ALLOC1(internal_UPDATE_VAL                      ,Tcontrol_t,_param->_nb_inst_update);
+    ALLOC1(internal_UPDATE_VAL_WITHOUT_ACK          ,Tcontrol_t,_param->_nb_inst_update);
+    ALLOC1(internal_UPDATE_CONTEXT_ID               ,Tcontext_t,_param->_nb_inst_update);
+    ALLOC1(internal_UPDATE_FROM_UFPT                ,bool      ,_param->_nb_inst_update);
+    ALLOC1(internal_UPDATE_DEPTH                    ,Tdepth_t  ,_param->_nb_inst_update);
+    ALLOC1(internal_UPDATE_RAS                      ,bool      ,_param->_nb_inst_update);
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    reg_TOP                     = new uint32_t  [_param->_nb_context];
+    reg_BOTTOM                  = new uint32_t  [_param->_nb_context];
+    reg_NB_ELT                  = new uint32_t  [_param->_nb_context];
+    reg_NB_ELT_UPDATE           = new uint32_t  [_param->_nb_context];
+    reg_NB_ELT_NEED_UPDATE      = new uint32_t  [_param->_nb_context];
+    reg_UPDATE_PREDICTION_TABLE = new entry_t * [_param->_nb_context];
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
+#ifndef NO_INIT
+        reg_TOP [i] = 0;
+#endif
+        reg_UPDATE_PREDICTION_TABLE [i] = new entry_t [_param->_size_queue[i]];
+    ALLOC1(reg_IS_ACCURATE                  ,bool         ,_param->_nb_context);
+    ALLOC2(reg_UPDATE_FETCH_PREDICTION_TABLE,ufpt_entry_t ,_param->_nb_context,_param->_size_ufpt_queue[it1]);
+    ALLOC1(reg_UFPT_BOTTOM                  ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_UFPT_TOP                     ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_UFPT_UPDATE                  ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_UFPT_NB_NEED_UPDATE          ,uint32_t     ,_param->_nb_context);
+    ALLOC2(reg_UPDATE_PREDICTION_TABLE      ,upt_entry_t  ,_param->_nb_context,_param->_size_upt_queue[it1]);
+    ALLOC1(reg_UPT_BOTTOM                   ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_UPT_TOP                      ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_UPT_UPDATE                   ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_UPT_NB_NEED_UPDATE           ,uint32_t     ,_param->_nb_context);
+    ALLOC1(reg_EVENT_STATE                  ,event_state_t,_param->_nb_context);
+    ALLOC1(reg_EVENT_RAS_CORRUPTED          ,Tcontrol_t   ,_param->_nb_context);
+    ALLOC1(reg_EVENT_ADDRESS_SRC            ,Taddress_t   ,_param->_nb_context);
+    ALLOC1(reg_EVENT_ADDRESS_SRC_VAL        ,Tcontrol_t   ,_param->_nb_context);
+    ALLOC1(reg_EVENT_ADDRESS_DEST           ,Taddress_t   ,_param->_nb_context);
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_deallocation.cpp

-              r82
+              r88
 #include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/include/Update_Prediction_Table.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
         delete []  in_PREDICT_RAS_ADDRESS         ;
         delete []  in_PREDICT_RAS_INDEX           ;
 //      if (_param->_have_port_depth)
 //      delete [] out_PREDICT_UPDATE_PREDICTION_ID;
+        if (_param->_have_port_depth)
+        delete [] out_PREDICT_UPDATE_PREDICTION_ID;
         // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
         delete []  in_DECOD_MISS_IFETCH           ;
         delete []  in_DECOD_MISS_DECOD            ;
         if (_param->_have_port_max_depth)
+        if (_param->_have_port_depth)
         delete []  in_DECOD_UPDATE_PREDICTION_ID  ;
 //      if (_param->_have_port_depth)
 //      delete [] out_DECOD_DEPTH                 ;
+        delete []  in_DECOD_IS_ACCURATE           ;
         // ~~~~~[ Interface : "branch_complete" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
         if (_param->_have_port_context_id)
         delete []  in_BRANCH_COMPLETE_CONTEXT_ID     ;
         if (_param->_have_port_max_depth)
+        if (_param->_have_port_depth)
         delete []  in_BRANCH_COMPLETE_DEPTH          ;
         delete []  in_BRANCH_COMPLETE_ADDRESS        ;
 …
 //      if (_param->_have_port_context_id)
 //      delete []  in_BRANCH_EVENT_CONTEXT_ID     ;
 //      if (_param->_have_port_max_depth)
+//      if (_param->_have_port_depth)
 //      delete []  in_BRANCH_EVENT_DEPTH          ;
 //      delete [] out_BRANCH_EVENT_MISS_PREDICTION;
 …
         // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         if (_param->_have_port_max_depth)
+        if (_param->_have_port_depth)
+          {
         delete [] out_DEPTH_NB_BRANCH;
         delete [] out_DEPTH_TAIL;
+        delete [] out_DEPTH_CURRENT;
+        delete [] out_DEPTH_MIN;
+          }
+      }
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete [] internal_PREDICT_ACK                     ;
+    delete [] internal_DECOD_ACK                       ;
+    delete [] internal_BRANCH_COMPLETE_ACK             ;
+    delete [] internal_BRANCH_COMPLETE_MISS_PREDICTION ;
+    delete [] internal_BRANCH_COMPLETE_TAKE            ;
+    delete [] internal_BRANCH_COMPLETE_ADDRESS_DEST    ;
+    delete [] internal_BRANCH_EVENT_VAL                ;
+    delete [] internal_BRANCH_EVENT_DEPTH              ;
+    delete [] internal_UPDATE_VAL                      ;
+    delete [] internal_UPDATE_CONTEXT_ID               ;
+    delete [] internal_UPDATE_DEPTH                    ;
+    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete [] reg_TOP;
+    delete [] reg_BOTTOM;
+    delete [] reg_NB_ELT;
+    delete [] reg_NB_ELT_UPDATE;
+    delete [] reg_NB_ELT_NEED_UPDATE;
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      delete [] reg_UPDATE_PREDICTION_TABLE [i];
+    delete [] reg_UPDATE_PREDICTION_TABLE;
+        delete [] out_DEPTH_MAX;
+        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        DELETE1(internal_PREDICT_ACK                     ,_param->_nb_inst_predict);
+        DELETE1(internal_PREDICT_UPDATE_PREDICTION_ID    ,_param->_nb_inst_predict);
+        DELETE1(internal_DECOD_ACK                       ,_param->_nb_inst_decod);
+        DELETE1(internal_DECOD_UPT_PTR_WRITE             ,_param->_nb_inst_decod);
+        DELETE1(internal_BRANCH_COMPLETE_ACK             ,_param->_nb_inst_branch_complete);
+        DELETE1(internal_BRANCH_COMPLETE_MISS_PREDICTION ,_param->_nb_inst_branch_complete);
+        DELETE1(internal_BRANCH_COMPLETE_TAKE            ,_param->_nb_inst_branch_complete);
+        DELETE1(internal_BRANCH_COMPLETE_ADDRESS_DEST    ,_param->_nb_inst_branch_complete);
+        DELETE1(internal_BRANCH_EVENT_VAL                ,_param->_nb_context);
+        DELETE1(internal_BRANCH_EVENT_DEPTH              ,_param->_nb_context);
+        DELETE1(internal_UPDATE_VAL                      ,_param->_nb_inst_update);
+        DELETE1(internal_UPDATE_VAL_WITHOUT_ACK          ,_param->_nb_inst_update);
+        DELETE1(internal_UPDATE_CONTEXT_ID               ,_param->_nb_inst_update);
+        DELETE1(internal_UPDATE_FROM_UFPT                ,_param->_nb_inst_update);
+        DELETE1(internal_UPDATE_DEPTH                    ,_param->_nb_inst_update);
+        DELETE1(internal_UPDATE_RAS                      ,_param->_nb_inst_update);
+        // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        DELETE1(reg_IS_ACCURATE                  ,_param->_nb_context);
+        DELETE2(reg_UPDATE_FETCH_PREDICTION_TABLE,_param->_nb_context,_param->_size_ufpt_queue[it1]);
+        DELETE1(reg_UFPT_BOTTOM                  ,_param->_nb_context);
+        DELETE1(reg_UFPT_TOP                     ,_param->_nb_context);
+        DELETE1(reg_UFPT_UPDATE                  ,_param->_nb_context);
+        DELETE1(reg_UFPT_NB_NEED_UPDATE          ,_param->_nb_context);
+        DELETE2(reg_UPDATE_PREDICTION_TABLE      ,_param->_nb_context,_param->_size_upt_queue[it1]);
+        DELETE1(reg_UPT_BOTTOM                   ,_param->_nb_context);
+        DELETE1(reg_UPT_TOP                      ,_param->_nb_context);
+        DELETE1(reg_UPT_UPDATE                   ,_param->_nb_context);
+        DELETE1(reg_UPT_NB_NEED_UPDATE           ,_param->_nb_context);
+        DELETE1(reg_EVENT_STATE                  ,_param->_nb_context);
+        DELETE1(reg_EVENT_RAS_CORRUPTED          ,_param->_nb_context);
+        DELETE1(reg_EVENT_ADDRESS_SRC            ,_param->_nb_context);
+        DELETE1(reg_EVENT_ADDRESS_SRC_VAL        ,_param->_nb_context);
+        DELETE1(reg_EVENT_ADDRESS_DEST           ,_param->_nb_context);
+       }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
     _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMealy_branch_complete.cpp

-              r82
+              r88
   void Update_Prediction_Table::genMealy_branch_complete (void)
+  {
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+    log_begin(Update_Prediction_Table,FUNCTION);
+    log_function(Update_Prediction_Table,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+#ifdef DEBUG_TEST
+      // just to don't have exception in not transaction
+      if (PORT_READ(in_BRANCH_COMPLETE_VAL [i]))
+#endif
+      {
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_COMPLETE [%d]",i);
         Tcontext_t          context   = (_param->_have_port_context_id)?PORT_READ(in_BRANCH_COMPLETE_CONTEXT_ID [i]):0;
         Tdepth_t            depth     = (_param->_have_port_max_depth )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
+        Tdepth_t            depth     = (_param->_have_port_depth     )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
         Tcontrol_t          miss      = false;
         Tcontrol_t          take      = reg_UPDATE_PREDICTION_TABLE [context][depth]._last_take   ;
         Taddress_t          addr_dest = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
         Tbranch_condition_t condition = reg_UPDATE_PREDICTION_TABLE [context][depth]._condition   ;
+        Tcontrol_t          flag      = PORT_READ(in_BRANCH_COMPLETE_FLAG [i]);
+        Taddress_t          addr_good = PORT_READ(in_BRANCH_COMPLETE_ADDRESS [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context        : %d",context);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth          : %d",depth  );
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition      : %s",toString(condition).c_str());
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * flag           : %d",flag);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * address_good   : %.8x",addr_good);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * (before)");
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * miss         : %d",miss);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * take         : %d",take);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * address_dest : %.8x",addr_dest);
         switch (condition)
 …
+            {
               //miss      : always hit
+              //addr_dest : know in decod stage
+              //addr_dest : compute in decod stage
+#ifdef DEBUG_TEST
+              if (take != 1)
+                throw ERRORMORPHEO(FUNCTION,toString("Branch_complete[%d] (condition %s) : bad direction.",i,toString(condition).c_str()));
+              if (addr_dest != addr_good)
+                throw ERRORMORPHEO(FUNCTION,toString("Branch_complete[%d] (condition %s) : bad destination address.",i,toString(condition).c_str()));
+#endif
               break;
+            }
           case BRANCH_CONDITION_FLAG_UNSET                        : // l.bnf
+            {
+              Tcontrol_t take_good = PORT_READ(in_BRANCH_COMPLETE_FLAG [i]) == 0;
+              //addr_dest : compute in decod stage
+              //miss if the direction is bad
+              Tcontrol_t take_good = not flag; // flag set = not take
               miss = (take != take_good);
               take = take_good;
+              //addr_dest : know in decod stage
+#ifdef DEBUG_TEST
+              if (addr_dest != addr_good)
+                throw ERRORMORPHEO(FUNCTION,toString("Branch_complete[%d] (condition %s) : bad destination address.",i,toString(condition).c_str()));
+#endif
               break;
+            }
           case BRANCH_CONDITION_FLAG_SET                          : // l.bf
+            {
+//            log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_CONDITION_FLAG_SET");
+              Tcontrol_t take_good = PORT_READ(in_BRANCH_COMPLETE_FLAG [i]) == 1;
+              //addr_dest : compute in decod stage
+              //miss if the direction is bad
+              Tcontrol_t take_good = flag; // flag set = take
               miss = (take != take_good);
               take = take_good;
+//            log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * flag      : %d",PORT_READ(in_BRANCH_COMPLETE_FLAG [i]));
+//            log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * take_good : %d",take_good);
 //            log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss      : %d",miss);
+              //addr_dest : know in decod stage
+#ifdef DEBUG_TEST
+              if (addr_dest != addr_good)
+                throw ERRORMORPHEO(FUNCTION,toString("Branch_complete[%d] (condition %s) : bad destination address.",i,toString(condition).c_str()));
+#endif
               break;
+            }
 …
           case BRANCH_CONDITION_READ_STACK                        : // l.jr (rb==r9)
+            {
+              Taddress_t addr_good = PORT_READ(in_BRANCH_COMPLETE_ADDRESS [i]);
+              miss = ((take == 1) and
+                      (addr_dest = addr_good));
+              take = 1;
+              // miss if destination address is bad
+              miss      = (addr_dest != addr_good);
               addr_dest = addr_good;
+#ifdef DEBUG_TEST
+              if (take != 1)
+                throw ERRORMORPHEO(FUNCTION,toString("Branch_complete[%d] (condition %s) : bad direction.",i,toString(condition).c_str()));
+#endif
               break;
+            }
+          }
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * miss      : %d",miss);
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * take      : %d",take);
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * address   : %x",addr_dest);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * (after)");
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * miss         : %d",miss);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * take         : %d",take);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * address_dest : %.8x",addr_dest);
         internal_BRANCH_COMPLETE_MISS_PREDICTION [i] = miss     ;
         internal_BRANCH_COMPLETE_TAKE            [i] = take     ;
         internal_BRANCH_COMPLETE_ADDRESS_DEST    [i] = addr_dest;
         PORT_WRITE(out_BRANCH_COMPLETE_MISS_PREDICTION [i], internal_BRANCH_COMPLETE_MISS_PREDICTION [i]);
         PORT_WRITE(out_BRANCH_COMPLETE_TAKE            [i], internal_BRANCH_COMPLETE_TAKE            [i]);
 …
+      }
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
+    log_end(Update_Prediction_Table,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMealy_decod.cpp

-              r82
+              r88
   void Update_Prediction_Table::genMealy_decod (void)
+  {
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+    log_begin(Update_Prediction_Table,FUNCTION);
+    log_function(Update_Prediction_Table,FUNCTION,_name.c_str());
+    // WARNING : One branch per context per cycle
     for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
+      {
         Tcontrol_t miss = PORT_READ(in_DECOD_MISS_DECOD [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * DECOD [%d]",i);
+        if (miss)
+          {
+            // miss : need a empty slot.
+            Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [i]):0;
+            uint32_t   top     = reg_TOP[context];
+            internal_DECOD_ACK [i] = (reg_UPDATE_PREDICTION_TABLE [context][top]._state == UPDATE_PREDICTION_STATE_EMPTY);
+          }
+        else
+          {
+            internal_DECOD_ACK [i] = true;
+          }
+        Tcontext_t    context     = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [i]):0;
+        bool          is_accurate = reg_IS_ACCURATE [context];
+        event_state_t event_state = reg_EVENT_STATE [context];
+        uint32_t      ptr_write   = reg_UPT_TOP     [context];
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * context     : %d",context    );
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * is_accurate : %d",is_accurate);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * event_state : %s",toString(event_state).c_str());
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * ptr_write   : %d",ptr_write  );
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * upt_state   : %s",toString(reg_UPDATE_PREDICTION_TABLE [context][ptr_write]._state).c_str());
+        // ack :
+        //   * in all case (miss or hit), need empty slot
+        //   * is_accurate
+        //   * event_state : don't update upt
+        internal_DECOD_ACK           [i] = ((reg_UPDATE_PREDICTION_TABLE [context][ptr_write]._state == UPDATE_PREDICTION_STATE_EMPTY) and
+                                            is_accurate and
+//                                             (
+                                             (event_state == EVENT_STATE_OK            )//  or
+//                                              (event_state == EVENT_STATE_FLUSH_UFPT    ) or
+//                                              (event_state == EVENT_STATE_UPDATE_CONTEXT))
+                                            );
+        internal_DECOD_UPT_PTR_WRITE [i] = ptr_write;
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * ack         : %d",internal_DECOD_ACK [i]);
         PORT_WRITE(out_DECOD_ACK [i], internal_DECOD_ACK [i]);
+      }
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
+    log_end(Update_Prediction_Table,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMealy_predict.cpp

-              r81
+              r88
   void Update_Prediction_Table::genMealy_predict (void)
+  {
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+    log_begin(Update_Prediction_Table,FUNCTION);
+    log_function(Update_Prediction_Table,FUNCTION,_name.c_str());
+    if (PORT_READ(in_NRESET) != 0)
+      {
     for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
+      {
         Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_PREDICT_CONTEXT_ID [i]):0;
         uint32_t   top     = reg_TOP[context];
+        uint32_t   top     = reg_UFPT_TOP[context];
 //      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"PREDICT [%d] (genMealy)",i);
 //      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * context     : %d",context);
 //      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * top         : %d",top);
 //      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * state       : %s",toString(reg_UPDATE_PREDICTION_TABLE [context][top]._state).c_str());
 //      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * is accurate : %d",PORT_READ(in_PREDICT_BTB_IS_ACCURATE [i]));
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"PREDICT [%d] (genMealy)",i);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * context     : %d",context);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * top         : %d",top);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * state       : %s",toString(reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._state).c_str());
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * is accurate : %d",PORT_READ(in_PREDICT_BTB_IS_ACCURATE [i]));
 //      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * need update : %d",reg_NB_ELT_NEED_UPDATE [context]);
+        // Not Full, accurate and no previous miss
+        // Optimisation to restart faster :
+        //   don't counter nb_elt_ko, but just nb_elt that need a update (change branch structure)
+        internal_PREDICT_ACK [i] = ((reg_UPDATE_PREDICTION_TABLE [context][top]._state == UPDATE_PREDICTION_STATE_EMPTY) and
+                                    PORT_READ(in_PREDICT_BTB_IS_ACCURATE [i]) and
+                                    (reg_NB_ELT_NEED_UPDATE [context] == 0));
+        internal_PREDICT_UPDATE_PREDICTION_ID [i] = top;
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * ACK         : %d",internal_PREDICT_ACK [i]);
+        if (_param->_have_port_depth)
+        PORT_WRITE(out_PREDICT_UPDATE_PREDICTION_ID [i], internal_PREDICT_UPDATE_PREDICTION_ID [i]);
+        bool is_accurate = not _param->_not_accurate_block_predict or reg_IS_ACCURATE[context];
+        // Ack if :
+        //  * slot is empty
+        //  * no previous miss
+        //  * is_accurate
+        internal_PREDICT_ACK [i] = ((reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._state == UPDATE_FETCH_PREDICTION_STATE_EMPTY) and
+//                                  PORT_READ(in_PREDICT_BTB_IS_ACCURATE [i]) and
+                                    (reg_EVENT_STATE [context] == EVENT_STATE_OK) and
+                                    is_accurate);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * ACK         : %d",internal_PREDICT_ACK [i]);
         PORT_WRITE(out_PREDICT_ACK [i], internal_PREDICT_ACK [i]);
+      }
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
+      }//don't reset
+    log_end(Update_Prediction_Table,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_genMoore.cpp

-              r82
+              r88
   void Update_Prediction_Table::genMoore (void)
+  {
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+    log_begin(Update_Prediction_Table,FUNCTION);
+    log_function(Update_Prediction_Table,FUNCTION,_name.c_str());
+    log_printf(NONE,Update_Prediction_Table,FUNCTION,FUNCTION);
+    if (PORT_READ(in_NRESET) == 1)
+      {
     // ===================================================================
 …
     for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
+        if (_param->_have_port_depth [i])
+          {
+            PORT_WRITE(out_DEPTH_TAIL      [i], reg_BOTTOM [i]);
+          }
+        PORT_WRITE(out_DEPTH_NB_BRANCH [i], reg_NB_ELT [i]);
+      }
+        if (_param->_have_port_depth)
+          {
+        PORT_WRITE(out_DEPTH_CURRENT [i], reg_UPT_TOP    [i]);
+        PORT_WRITE(out_DEPTH_MIN     [i], reg_UPT_BOTTOM [i]);
+          }
+        PORT_WRITE(out_DEPTH_MAX     [i], reg_UPT_TOP    [i]);
+      }
     // ===================================================================
     // =====[ UPDATE ]====================================================
     // ===================================================================
+    Tdepth_t tab_depth [_param->_nb_context];
+    bool     retire_ras_from_ufpt [_param->_nb_context]; // event ufpt -> restore RAS, else update upt
+    bool     retire_ras_from_upt  [_param->_nb_context]; // event upt  -> restore RAS, else restore others structure
+    bool     ufpt_update          [_param->_nb_context];
+    bool     upt_update           [_param->_nb_context];
+    Tdepth_t tab_ufpt_depth       [_param->_nb_context];
+    Tdepth_t tab_upt_depth        [_param->_nb_context];
     for (uint32_t i=0; i<_param->_nb_context; i++)
+      tab_depth [i] = reg_BOTTOM [i];
+      {
+        event_state_t event_state = reg_EVENT_STATE [i];
+        retire_ras_from_ufpt [i] = ((event_state == EVENT_STATE_FLUSH_UFPT        ) or
+                                    (event_state == EVENT_STATE_FLUSH_UFPT_AND_UPT));
+        retire_ras_from_upt  [i] = (event_state == EVENT_STATE_FLUSH_UPT_RAS);
+        ufpt_update          [i] = true;
+        upt_update           [i] = true;
+        tab_ufpt_depth       [i] = reg_UFPT_UPDATE [i];
+        tab_upt_depth        [i] = reg_UPT_UPDATE  [i];
+      }
     for (uint32_t i=0; i<_param->_nb_inst_update; i++)
+      {
+        uint32_t   context = (reg_UPDATE_PRIORITY+i)%_param->_nb_context;
+        Tdepth_t   depth   = tab_depth[context];
+        state_t    state   = reg_UPDATE_PREDICTION_TABLE [context][depth]._state;
+        Tcontext_t          context     = (reg_UPDATE_PRIORITY+i)%_param->_nb_context;
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE [%d] (genMoore)",i);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context         : %d",context);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * event_state     : %s",toString(reg_EVENT_STATE [context]).c_str());
+        Tcontrol_t          val                  = false;
+        Tcontrol_t          val_without_ack      = false;
+        Tcontrol_t          miss_prediction      ;
+        Tcontrol_t          direction_good       ;
+        Tcontrol_t          btb_val              ;
+        Taddress_t          btb_address_src      ;
+        Taddress_t          btb_address_dest     ;
+        Tbranch_condition_t btb_condition        ;
+        Tcontrol_t          dir_val              ;
+        Thistory_t          dir_history          ;
+        Tcontrol_t          ras_val              ;
+        Tcontrol_t          ras_push             ;
+        Taddress_t          ras_address          ;
+        Tptr_t              ras_index            ;
+        Tcontrol_t          ras_prediction_ifetch;
+        // Test if update fetch prediction table need update port
+        if (retire_ras_from_ufpt [context])
+          {
+            if (ufpt_update [context])
+              {
+                // Update Fetch Prediction Table
+                // An update of ufpt is to previous miss. Just restore Return Address Stack
+                Tdepth_t            depth     = tab_ufpt_depth[context];
+                ufpt_state_t        state     = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state;
+                Tbranch_condition_t condition = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition;
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
+                val                   = (state == UPDATE_FETCH_PREDICTION_STATE_EVENT);
+                miss_prediction       = 1;
+//              direction_good        = ;
+                btb_val               = 0; // don't update btb (is update by the event branch)
+//              btb_address_src       = ;
+//              btb_address_dest      = ;
+//              btb_condition         = ;
+                dir_val               = 0; // don't update btb (is update by the event branch (if conditionnal branch))
+//              dir_history           = ;
+                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
+                ras_push              = push_ras(condition);
+                ras_address           = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._address_ras;
+                ras_index             = reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._index_ras;
+                ras_prediction_ifetch = 1;
+                internal_UPDATE_FROM_UFPT [i] = true;
+                internal_UPDATE_DEPTH     [i] = depth;
+                internal_UPDATE_RAS       [i] = false;
+                // Warning : don't update same entry
+                if (depth == reg_UFPT_BOTTOM[context])
+                  ufpt_update [context] = false;
+                tab_ufpt_depth[context] = (depth==0)?(_param->_size_ufpt_queue[context]-1):(depth-1);
+              }
+          }
+        else
+          {
+            if (upt_update [context])
+              {
+                // Update Prediction Table
+                Tdepth_t            depth     = tab_upt_depth[context];
+                upt_state_t         state     = reg_UPDATE_PREDICTION_TABLE [context][depth]._state;
+                Tbranch_condition_t condition = reg_UPDATE_PREDICTION_TABLE [context][depth]._condition;
+                Tcontrol_t          ifetch    = reg_UPDATE_PREDICTION_TABLE [context][depth]._ifetch_prediction;
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth           : %d",depth    );
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state           : %s",toString(state    ).c_str());
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * condition       : %s",toString(condition).c_str());
+                Tcontrol_t          state_is_ok_ko           = ((state == UPDATE_PREDICTION_STATE_OK) or
+                                                                (state == UPDATE_PREDICTION_STATE_KO));
+                Tcontrol_t          state_is_event           = (state == UPDATE_PREDICTION_STATE_EVENT);
+                Tcontrol_t          state_is_event_update    = state_is_event and     need_update(condition);
+                Tcontrol_t          state_is_event_no_update = state_is_event and not need_update(condition);
+                if (retire_ras_from_upt [context])
+                  {
+                val                   = state_is_event_update;
+                val_without_ack       = state_is_event_no_update;
+                  }
+                else
+                  {
+                val                   = state_is_ok_ko;
+                val_without_ack       = false;
+                  }
+                miss_prediction       = (state != UPDATE_PREDICTION_STATE_OK);
+                direction_good        = reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   ;
+                btb_val               = update_btb(condition);
+                btb_address_src       = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src ;
+                btb_address_dest      = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest;
+                btb_condition         = condition;
+                dir_val               = update_dir(condition) and ifetch; // if not ifetch, then static prediction
+                dir_history           = reg_UPDATE_PREDICTION_TABLE [context][depth]._history     ;
+                ras_val               = update_ras(condition); // repop/ repush data -> don't corrupt ras
+                ras_push              = push_ras(condition);
+                ras_address           = reg_UPDATE_PREDICTION_TABLE [context][depth]._address_ras;
+                ras_index             = reg_UPDATE_PREDICTION_TABLE [context][depth]._index_ras;
+                ras_prediction_ifetch = ifetch;
+                internal_UPDATE_FROM_UFPT [i] = false;
+                internal_UPDATE_DEPTH     [i] = depth;
+                internal_UPDATE_RAS       [i] = retire_ras_from_upt [context];
+                // Warning : don't update same entry
+                if (retire_ras_from_upt [context])
+                  {
+                    // Restore RAS.
+                    if ((depth == reg_UPT_BOTTOM[context]) or not (val or val_without_ack))
+                      upt_update [context] = false;
+                    tab_upt_depth[context] = (depth==0)?(_param->_size_upt_queue[context]-1):(depth-1);
+                  }
+                else
+                  {
+                    if ((depth == reg_UPT_TOP [context]) or not (val or val_without_ack))
+                      upt_update [context] = false;
+                    tab_upt_depth[context] = (depth+1)%_param->_size_upt_queue[context];
+                  }
+              }
+          }
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val             : %d",val    );
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * val_without_ack : %d",val_without_ack);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * btb_val         : %d",btb_val);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * dir_val         : %d",dir_val);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * ras_val         : %d",ras_val);
+        internal_UPDATE_VAL             [i] = val;
+        internal_UPDATE_VAL_WITHOUT_ACK [i] = val_without_ack;
+        internal_UPDATE_CONTEXT_ID      [i] = context;
+        PORT_WRITE(out_UPDATE_VAL                   [i],internal_UPDATE_VAL [i]);
+        if (val)
+          {
+        if (_param->_have_port_context_id)
+        PORT_WRITE(out_UPDATE_CONTEXT_ID            [i],context              );
+        PORT_WRITE(out_UPDATE_MISS_PREDICTION       [i],miss_prediction      );
+        PORT_WRITE(out_UPDATE_DIRECTION_GOOD        [i],direction_good       );
+        PORT_WRITE(out_UPDATE_BTB_VAL               [i],btb_val              );
+        PORT_WRITE(out_UPDATE_BTB_ADDRESS_SRC       [i],btb_address_src      );
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * address_src     : %.8x",btb_address_src);
+        PORT_WRITE(out_UPDATE_BTB_ADDRESS_DEST      [i],btb_address_dest     );
+        PORT_WRITE(out_UPDATE_BTB_CONDITION         [i],btb_condition        );
+        PORT_WRITE(out_UPDATE_DIR_VAL               [i],dir_val              );
+        if (_param->_have_port_history)
+        PORT_WRITE(out_UPDATE_DIR_HISTORY           [i],dir_history          );
+        PORT_WRITE(out_UPDATE_RAS_VAL               [i],ras_val              );
+        PORT_WRITE(out_UPDATE_RAS_PUSH              [i],ras_push             );
+        PORT_WRITE(out_UPDATE_RAS_ADDRESS           [i],ras_address          );
+        PORT_WRITE(out_UPDATE_RAS_INDEX             [i],ras_index            );
+        PORT_WRITE(out_UPDATE_RAS_PREDICTION_IFETCH [i],ras_prediction_ifetch);
+          }
+      }
+//     // ===================================================================
+//     // =====[ BRANCH_EVENT ]==============================================
+//     // ===================================================================
+//     for (uint32_t i=0; i<_param->_nb_context; i++)
+//       {
+//      Tdepth_t   depth   = (reg_BOTTOM [i] + reg_NB_ELT_UPDATE [i])%_param->_size_queue [i];
+//      state_t    state   = reg_UPDATE_PREDICTION_TABLE [i][depth]._state;
+        Tcontrol_t val     = ((state == UPDATE_PREDICTION_STATE_OK) or
+                              (state == UPDATE_PREDICTION_STATE_KO));
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"UPDATE [%d] (genMoore)",i);
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * context     : %d",context);
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * depth       : %d",depth);
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * state       : %s",toString(state).c_str());
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * val         : %d",val);
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * addr_src    : %x",reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src );
+//      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * addr_dest   : %x",reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest);
+        if (val)
+          {
+            Tbranch_condition_t cond    = reg_UPDATE_PREDICTION_TABLE [context][depth]._condition;
+            Tcontrol_t          ifetch  = reg_UPDATE_PREDICTION_TABLE [context][depth]._ifetch_prediction;
+            Tcontrol_t          btb_val = true;
+            Tcontrol_t          dir_val = (ifetch and // not ifetch == static prediction
+                                           ((cond == BRANCH_CONDITION_FLAG_UNSET) or
+                                            (cond == BRANCH_CONDITION_FLAG_SET)));
+            Tcontrol_t          ras_val = ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+                                           (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or
+                                           (cond == BRANCH_CONDITION_READ_STACK));
+            Tcontrol_t          push = ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+                                        (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK));
+            if (_param->_have_port_context_id)
+            PORT_WRITE(out_UPDATE_CONTEXT_ID            [i],context);
+            PORT_WRITE(out_UPDATE_MISS_PREDICTION       [i],(state == UPDATE_PREDICTION_STATE_KO));
+            PORT_WRITE(out_UPDATE_DIRECTION_GOOD        [i],reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take   );
+            PORT_WRITE(out_UPDATE_BTB_VAL               [i],btb_val);
+            PORT_WRITE(out_UPDATE_BTB_ADDRESS_SRC       [i],reg_UPDATE_PREDICTION_TABLE [context][depth]._address_src );
+            PORT_WRITE(out_UPDATE_BTB_ADDRESS_DEST      [i],reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest);
+            PORT_WRITE(out_UPDATE_BTB_CONDITION         [i],cond);
+            PORT_WRITE(out_UPDATE_DIR_VAL               [i],dir_val);
+            if (_param->_have_port_history)
+            PORT_WRITE(out_UPDATE_DIR_HISTORY           [i],reg_UPDATE_PREDICTION_TABLE [context][depth]._history     );
+            PORT_WRITE(out_UPDATE_RAS_VAL               [i],ras_val);
+            PORT_WRITE(out_UPDATE_RAS_PUSH              [i],push);
+            PORT_WRITE(out_UPDATE_RAS_ADDRESS           [i],reg_UPDATE_PREDICTION_TABLE [context][depth]._address_ras );
+            PORT_WRITE(out_UPDATE_RAS_INDEX             [i],reg_UPDATE_PREDICTION_TABLE [context][depth]._index_ras   );
+            PORT_WRITE(out_UPDATE_RAS_PREDICTION_IFETCH [i],ifetch);
+            internal_UPDATE_CONTEXT_ID [i] = context;
+            internal_UPDATE_DEPTH      [i] = depth;
+            tab_depth[context] = (depth+1)%_param->_size_queue[context];
+          }
+        internal_UPDATE_VAL [i] = val;
+        PORT_WRITE(out_UPDATE_VAL [i], internal_UPDATE_VAL [i]);
+      }
+    // ===================================================================
+    // =====[ BRANCH_EVENT ]==============================================
+    // ===================================================================
+    for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
+        Tdepth_t   depth   = (reg_BOTTOM [i] + reg_NB_ELT_UPDATE [i])%_param->_size_queue [i];
+        state_t    state   = reg_UPDATE_PREDICTION_TABLE [i][depth]._state;
+        Tcontrol_t val     = (state == UPDATE_PREDICTION_STATE_EVENT);
+        if (val)
+          {
+            PORT_WRITE(out_BRANCH_EVENT_ADDRESS_SRC  [i], reg_UPDATE_PREDICTION_TABLE [i][depth]._address_src );
+            PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST [i], reg_UPDATE_PREDICTION_TABLE [i][depth]._address_dest);
+            internal_BRANCH_EVENT_DEPTH [i] = depth;
+          }
+        internal_BRANCH_EVENT_VAL   [i] = val;
+        PORT_WRITE(out_BRANCH_EVENT_VAL [i], internal_BRANCH_EVENT_VAL [i]);
+      }
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
+//      Tcontrol_t val     = ((state == UPDATE_PREDICTION_STATE_EVENT) or
+//                               (state == UPDATE_PREDICTION_STATE_WAITEND_AND_EVENT));
+//      if (val)
+//        {
+// //          breakpoint ("UPT : have an branch_event (depth %d)",depth);
+//          PORT_WRITE(out_BRANCH_EVENT_ADDRESS_SRC  [i], reg_UPDATE_PREDICTION_TABLE [i][depth]._address_src );
+//          PORT_WRITE(out_BRANCH_EVENT_ADDRESS_DEST [i], reg_UPDATE_PREDICTION_TABLE [i][depth]._address_dest);
+//          internal_BRANCH_EVENT_DEPTH [i] = depth;
+//        }
+//      internal_BRANCH_EVENT_VAL   [i] = val;
+//      PORT_WRITE(out_BRANCH_EVENT_VAL [i], internal_BRANCH_EVENT_VAL [i]);
+//       }
+      }
+    log_end(Update_Prediction_Table,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_statistics_allocation.cpp

-              r81
+              r88
                       "Update_Prediction_Table",
                       param_statistics);
+//     _stat_nb_branch_hit        = new counter_t * [_param->_nb_context];
+//     _stat_nb_branch_miss       = new counter_t * [_param->_nb_context];
+//     _stat_nb_branch_unused     = new counter_t * [_param->_nb_context];
+//     _stat_queue_nb_cycle_empty = new counter_t * [_param->_nb_context];
+//     _stat_queue_nb_cycle_full  = new counter_t * [_param->_nb_context];
+//     _stat_queue_nb_elt         = new counter_t * [_param->_nb_context];
+//     for (uint32_t i=0; i<_param->_nb_context; ++i)
+//       {
+//         _stat_nb_branch_hit        [i] = _stat->create_counter("nb_branch_hit_"       +toString(i),"",toString(_("Branch hit speculation (context %d)"),i));
+//         _stat_nb_branch_miss       [i] = _stat->create_counter("nb_branch_miss_"      +toString(i),"",toString(_("Branch miss speculation (context %d)"),i));
+//         _stat_nb_branch_unused     [i] = _stat->create_counter("nb_branch_unused_"    +toString(i),"",toString(_("Branch unused, because an previous branch have miss speculation (context %d)"),i));
+//         _stat_queue_nb_cycle_empty [i] = _stat->create_counter("queue_nb_cycle_empty_"+toString(i),"",toString(_("Cycle number where the Update Prediction Table is empty (context %d)"),i));
+//         _stat_queue_nb_cycle_full  [i] = _stat->create_counter("queue_nb_cycle_full_" +toString(i),"",toString(_("Cycle number where the Update Prediction Table is full (%d elements) (context %d)"),_param->_size_queue[i],i));
+//         _stat_queue_nb_elt         [i] = _stat->create_counter("queue_nb_elt_"        +toString(i),"",toString(_("Average branchement by cycle in Update Prediction Table (context %d)"),i));
+//       }
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_statistics_deallocation.cpp

-              r81
+              r88
     log_printf(INFO,Update_Prediction_Table,FUNCTION,"Generate Statistics file");
+    delete _stat;
+    delete    _stat;
+//     delete [] _stat_nb_branch_hit       ;
+//     delete [] _stat_nb_branch_miss      ;
+//     delete [] _stat_nb_branch_unused    ;
+//     delete [] _stat_queue_nb_cycle_empty;
+//     delete [] _stat_queue_nb_cycle_full ;
+//     delete [] _stat_queue_nb_elt        ;
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table/src/Update_Prediction_Table_transition.cpp

-              r82
+              r88
 namespace update_prediction_table {
 #undef  FUNCTION
 #define FUNCTION "Update_Prediction_Table::transition"
   void Update_Prediction_Table::transition (void)
+  {
+    log_printf(FUNC,Update_Prediction_Table,FUNCTION,"Begin");
+    log_begin(Update_Prediction_Table,FUNCTION);
+    log_function(Update_Prediction_Table,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
+      {
+        // Initialisation
+        reg_UPDATE_PRIORITY = 0;
+        // All pointer is set at 0
         for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            reg_TOP                [i] = 0;
+            reg_BOTTOM             [i] = 0;
+            reg_NB_ELT             [i] = 0;
+            reg_NB_ELT_UPDATE      [i] = 0;
+            reg_NB_ELT_NEED_UPDATE [i] = 0;
+            for (uint32_t j=0; j<_param->_size_queue[i]; j++)
+              reg_UPDATE_PREDICTION_TABLE [i][j]._state = UPDATE_PREDICTION_STATE_EMPTY;
+          }
+        reg_UPDATE_PRIORITY = 0;
+            for (uint32_t j=0; j<_param->_size_ufpt_queue[i]; ++j)
+              reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._state = UPDATE_FETCH_PREDICTION_STATE_EMPTY;
+            reg_UFPT_BOTTOM          [i] = 0;
+            reg_UFPT_TOP             [i] = 0;
+            reg_UFPT_UPDATE          [i] = 0;
+            reg_UFPT_NB_NEED_UPDATE  [i] = 0;
+            for (uint32_t j=0; j<_param->_size_upt_queue[i]; ++j)
+              reg_UPDATE_PREDICTION_TABLE [i][j]._state = UPDATE_PREDICTION_STATE_EMPTY;
+            reg_UPT_BOTTOM           [i] = 0;
+            reg_UPT_TOP              [i] = 0;
+            reg_UPT_UPDATE           [i] = 0;
+            reg_UPT_NB_NEED_UPDATE   [i] = 0;
+            reg_IS_ACCURATE          [i] = true;
+            reg_EVENT_STATE          [i] = EVENT_STATE_OK;
+          }
+      }
     else
+      {
         // ===================================================================
+        // =====[ GARBAGE COLLECTOR ]=========================================
+        // ===================================================================
+        // Each cycle, if the most lastest branch have update all prediction struction (state = end), free this slot
+        //   * Update state -> new status is "empty"
+        //   * Update pointer (bottom and accurate)
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * GARBAGE COLLECTOR");
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            // UPDATE_FETCH_PREDICTION_TABLE
+            {
+              uint32_t bottom = reg_UFPT_BOTTOM [i];
+              // Test if state is end
+              if (reg_UPDATE_FETCH_PREDICTION_TABLE [i][bottom]._state == UPDATE_FETCH_PREDICTION_STATE_END)
+                {
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d]",i,bottom);
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state =  UPDATE_FETCH_PREDICTION_STATE_EMPTY",i,bottom);
+                  // Free slot
+                  reg_UPDATE_FETCH_PREDICTION_TABLE [i][bottom]._state = UPDATE_FETCH_PREDICTION_STATE_EMPTY;
+                  // Update pointer
+                  reg_UFPT_BOTTOM [i] = (bottom+1)%_param->_size_ufpt_queue[i];
+                }
+            }
+            // UPDATE_PREDICTION_TABLE
+            {
+              uint32_t bottom = reg_UPT_BOTTOM [i];
+              // Test if state is end
+              if (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END)
+                {
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT [%d][%d]",i,bottom);
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT [%d][%d]._state =  UPDATE_PREDICTION_STATE_EMPTY",i,bottom);
+                  // Free slot
+                  reg_UPDATE_PREDICTION_TABLE [i][bottom]._state = UPDATE_PREDICTION_STATE_EMPTY;
+                  // Update pointer
+                  reg_UPT_BOTTOM [i] = (bottom+1)%_param->_size_upt_queue[i];
+                }
+            }
+          }
+        // ===================================================================
         // =====[ PREDICT ]===================================================
         // ===================================================================
+        // An ifetch_unit compute next cycle and have an branch : predict_val is set
+        //   * Alloc new entry -> new status is "wait decod"
+        //   * Save input (to restore in miss or error)
+        //   * Update pointer
         for (uint32_t i=0; i<_param->_nb_inst_predict; i++)
           if (PORT_READ(in_PREDICT_VAL[i]) and internal_PREDICT_ACK [i])
+            {
               Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_PREDICT_CONTEXT_ID [i]):0;
+              uint32_t   top     = reg_TOP [context];
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"PREDICT[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * top     : %d",top);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * nb_elt  : %d",reg_NB_ELT[context]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._state        = UPDATE_PREDICTION_STATE_WAIT_DECOD;
+              reg_UPDATE_PREDICTION_TABLE [context][top]._ifetch_prediction = true;
+              reg_UPDATE_PREDICTION_TABLE [context][top]._condition    = PORT_READ(in_PREDICT_BTB_CONDITION    [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._address_src  = PORT_READ(in_PREDICT_BTB_ADDRESS_SRC  [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._address_dest = PORT_READ(in_PREDICT_BTB_ADDRESS_DEST [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._last_take    = PORT_READ(in_PREDICT_BTB_LAST_TAKE    [i]);
+            //reg_UPDATE_PREDICTION_TABLE [context][top]._good_take
+              reg_UPDATE_PREDICTION_TABLE [context][top]._history      = (_param->_have_port_history)?PORT_READ(in_PREDICT_DIR_HISTORY [i]):0;
+              reg_UPDATE_PREDICTION_TABLE [context][top]._address_ras  = PORT_READ(in_PREDICT_RAS_ADDRESS      [i]);
+              reg_UPDATE_PREDICTION_TABLE [context][top]._index_ras    = PORT_READ(in_PREDICT_RAS_INDEX        [i]);
+              reg_TOP    [context] = (top+1)%_param->_size_queue [context];
+              reg_NB_ELT [context] ++;
+              uint32_t   top     = internal_PREDICT_UPDATE_PREDICTION_ID [i];
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * PREDICT[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * top     : %d",top);
+#ifdef DEBUG_TEST
+              if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._state != UPDATE_FETCH_PREDICTION_STATE_EMPTY)
+                throw ERRORMORPHEO(FUNCTION,_("Predict : invalid state."));
+#endif
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_WAIT_DECOD (predict)",context,top);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._state        = UPDATE_FETCH_PREDICTION_STATE_WAIT_DECOD;
+              Tbranch_condition_t condition = PORT_READ(in_PREDICT_BTB_CONDITION [i]);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._condition    = condition;
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._address_src  = PORT_READ(in_PREDICT_BTB_ADDRESS_SRC  [i]);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._address_dest = PORT_READ(in_PREDICT_BTB_ADDRESS_DEST [i]);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._last_take    = PORT_READ(in_PREDICT_BTB_LAST_TAKE    [i]);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._is_accurate  = PORT_READ(in_PREDICT_BTB_IS_ACCURATE  [i]);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._history      = (_param->_have_port_history)?PORT_READ(in_PREDICT_DIR_HISTORY [i]):0;
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._address_ras  = PORT_READ(in_PREDICT_RAS_ADDRESS      [i]);
+              reg_UPDATE_FETCH_PREDICTION_TABLE [context][top]._index_ras    = PORT_READ(in_PREDICT_RAS_INDEX        [i]);
+              reg_UFPT_TOP     [context] = (top+1)%_param->_size_ufpt_queue [context];
+//            reg_UFPT_UPDATE  [context] = reg_UFPT_TOP [context];
+              if (need_update(condition))
+                reg_UFPT_NB_NEED_UPDATE [context] ++;
+            }
 …
         // =====[ DECOD ]=====================================================
         // ===================================================================
+        // An decod is detected by decod stage
+        //   1) Hit prediction : The instruction bundle have a branch predicted in ifetch stage and it is this branch
+        //      * Update state, wait_decod -> wait_end
+        //      * Pop ufpt -> push upt
+        //      * Update accurate register : if the predict stage have tagged this branch as not accurate, stop decod
+        //   2) Miss           : The instruction bundle have a branch but it is not predicted
+        //      * Flush ufpt
+        //      * decod information is write in upt
         for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
           if (PORT_READ(in_DECOD_VAL[i]) and internal_DECOD_ACK [i])
+            {
+              Tcontext_t context     = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [i]):0;
+              Tcontrol_t miss_ifetch = PORT_READ(in_DECOD_MISS_IFETCH [i]);
+              Tcontrol_t miss_decod  = PORT_READ(in_DECOD_MISS_DECOD  [i]);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"DECOD[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context     : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * miss_ifetch : %d",miss_ifetch);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * miss_decod  : %d",miss_decod);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * nb_elt      : %d",reg_NB_ELT[context]);
+              Tcontext_t          context       = (_param->_have_port_context_id)?PORT_READ(in_DECOD_CONTEXT_ID [i]):0;
+              Tcontrol_t          miss_ifetch   = PORT_READ(in_DECOD_MISS_IFETCH [i]);
+              Tcontrol_t          miss_decod    = PORT_READ(in_DECOD_MISS_DECOD  [i]);
+              uint32_t            upt_ptr_write = internal_DECOD_UPT_PTR_WRITE [i];
+              Tbranch_condition_t condition  ;
+              Tcontrol_t          is_accurate;
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * DECOD[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context       : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_ifetch   : %d",miss_ifetch);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss_decod    : %d",miss_decod);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * upt_ptr_write : %d",upt_ptr_write);
+              // Test if miss ifetch
+              //   miss ifetch = decod a branch and the predict unit have not predict this branch ... gloup :P
+              if (miss_ifetch or miss_decod)
+              if (miss_ifetch or miss_decod)
+                {
+                  Tdepth_t depth = (_param->_have_port_max_depth)?PORT_READ(in_DECOD_UPDATE_PREDICTION_ID [i]):0;
+                  Tdepth_t top   = reg_TOP [context];
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._state        = UPDATE_PREDICTION_STATE_WAITEND;
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._ifetch_prediction = false; // static prediction
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._condition    = PORT_READ(in_DECOD_BTB_CONDITION    [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._address_src  = PORT_READ(in_DECOD_BTB_ADDRESS_SRC  [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._address_dest = PORT_READ(in_DECOD_BTB_ADDRESS_DEST [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._last_take    = PORT_READ(in_DECOD_BTB_LAST_TAKE    [i]);
+                //reg_UPDATE_PREDICTION_TABLE [context][top]._good_take
+                //reg_UPDATE_PREDICTION_TABLE [context][top]._history
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._address_ras  = PORT_READ(in_DECOD_RAS_ADDRESS      [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][top]._index_ras    = PORT_READ(in_DECOD_RAS_INDEX        [i]);
+                  // Invalid all previous "ifetch" prediction
+                  // (ifetch prediction = prediction make in fetch stage and not again comming in decod stage)
+                  uint32_t nb_elt_miss        = ((top> depth)?top:(top+_param->_size_queue[context]))-depth;
+                  uint32_t nb_elt_need_update = 0;
+                  for (uint32_t j=0; j<nb_elt_miss; j++)
+                    {
+                      uint32_t k=(depth+j)%_param->_size_queue[context];
+                      // Ifetch have make a prediction and it's a miss
+                      // When ifetch predict :
+                      //   * btb is not change       -> needn't update
+                      //   * direction is not change -> needn't update
+                      //   * ras have change         -> need    update
+                      Tbranch_condition_t cond = reg_UPDATE_PREDICTION_TABLE [context][k]._condition;
+                      if ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_STACK))
+                        {
+                          nb_elt_need_update ++;
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_KO;
+                        }
+                      else
+                        {
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_END;
+                        }
+                    }
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_EVENT; // rewrite
+                  reg_TOP                [context] = (depth+1)%_param->_size_queue [context];
+                  reg_NB_ELT_NEED_UPDATE [context] += nb_elt_need_update;
+                  reg_NB_ELT             [context] ++;
+                  // Have a miss !!!
+                  // Flush UPFT
+                  // It's to accelerate miss speculation
+                  if (reg_UFPT_NB_NEED_UPDATE [context] == 0)
+                    {
+                      // No entry need prediction, flush all entry -> Reset
+                      for (uint32_t j=0; j<_param->_size_ufpt_queue[context]; ++j)
+                        reg_UPDATE_FETCH_PREDICTION_TABLE [context][j]._state = UPDATE_FETCH_PREDICTION_STATE_EMPTY;
+                      reg_UFPT_BOTTOM [context] = 0;
+                      reg_UFPT_TOP    [context] = 0;
+//                    reg_UFPT_UPDATE [context] = 0;
+                    }
+                  else
+                    {
+                      reg_UFPT_UPDATE [context] = reg_UFPT_TOP [context];
+#ifdef DEBUG_TEST
+                      if (reg_EVENT_STATE [context] == EVENT_STATE_OK)
+                        throw ERRORMORPHEO(FUNCTION,_("Decod : invalid event state."));
+#endif
+                      // Change state
+                      log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * EVENT [%d] <- EVENT_STATE_FLUSH_UFPT (decod - miss)",context);
+                      reg_EVENT_STATE [context] = EVENT_STATE_FLUSH_UFPT;
+                    }
+                  // Push upt (from decod interface)
+                  condition   = PORT_READ(in_DECOD_BTB_CONDITION [i]);
+                  is_accurate = PORT_READ(in_DECOD_IS_ACCURATE   [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._condition         = condition;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._address_src       = PORT_READ(in_DECOD_BTB_ADDRESS_SRC  [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._address_dest      = PORT_READ(in_DECOD_BTB_ADDRESS_DEST [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._last_take         = PORT_READ(in_DECOD_BTB_LAST_TAKE    [i]);
+//                reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._good_take;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._is_accurate       = is_accurate;
+//                reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._history           = ; // static prediction
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._address_ras       = PORT_READ(in_DECOD_RAS_ADDRESS [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._index_ras         = PORT_READ(in_DECOD_RAS_INDEX   [i]);
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._ifetch_prediction = false; // static prediction
+                }
               else
+                {
                   // Normal case : branch is previous predicated, change state of branch
+                  Tdepth_t depth = (_param->_have_port_max_depth)?PORT_READ(in_DECOD_UPDATE_PREDICTION_ID [i]):0;
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_WAITEND;
+                  uint32_t ufpt_ptr_read = (_param->_have_port_depth)?PORT_READ(in_DECOD_UPDATE_PREDICTION_ID [i]):0;
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * ufpt_ptr_read : %d",ufpt_ptr_read);
+#ifdef DEBUG_TEST
+                  if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._state != UPDATE_FETCH_PREDICTION_STATE_WAIT_DECOD)
+                    throw ERRORMORPHEO(FUNCTION,_("Decod : invalid ufpt state."));
+#endif
+                  // Change state
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_END (decod - hit)",context,ufpt_ptr_read);
+                  reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._state = UPDATE_FETCH_PREDICTION_STATE_END;
+                  // Push upt (from Pop ufpt)
+                  condition   = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._condition;
+                  is_accurate = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._is_accurate;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._condition         = condition;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._address_src       = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._address_src ;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._address_dest      = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._address_dest;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._last_take         = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._last_take   ;
+//                reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._good_take;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._is_accurate       = is_accurate;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._history           = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._history     ;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._address_ras       = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._address_ras ;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._index_ras         = reg_UPDATE_FETCH_PREDICTION_TABLE [context][ufpt_ptr_read]._index_ras   ;
+                  reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._ifetch_prediction = true; // prediction from ifetch
+                  // Update pointer
+                  if (need_update(condition))
+                    {
+                      reg_UFPT_NB_NEED_UPDATE [context] --;
+                    }
+                }
+              // All case !!!
+#ifdef DEBUG_TEST
+              if (reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._state != UPDATE_PREDICTION_STATE_EMPTY)
+                throw ERRORMORPHEO(FUNCTION,_("Decod : invalid upt state."));
+#endif
+              // Change state
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_WAIT_END (decod - hit)",context,upt_ptr_write);
+              reg_UPDATE_PREDICTION_TABLE [context][upt_ptr_write]._state = UPDATE_PREDICTION_STATE_WAIT_END;
+              // Write new accurate
+#ifdef DEBUG_TEST
+              if (not reg_IS_ACCURATE [context]  and not is_accurate)
+                throw ERRORMORPHEO(FUNCTION,_("Decod : invalid accurate flag."));
+#endif
+              reg_IS_ACCURATE [context] = is_accurate;
+              // Update pointer
+              reg_UPT_TOP     [context] = (upt_ptr_write+1)%_param->_size_upt_queue [context];
+//            reg_UPT_UPDATE  [context] = reg_UPT_TOP [context];
+              if (need_update(condition))
+                {
+                  reg_UPT_NB_NEED_UPDATE  [context] ++;
+                }
+            }
 …
         // =====[ BRANCH_COMPLETE ]===========================================
         // ===================================================================
+        // The branch is complete
+        //   * Hit  prediction :
+        //     * update status
+        //   * Miss prediction :
         for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
           if (PORT_READ(in_BRANCH_COMPLETE_VAL[i]) and internal_BRANCH_COMPLETE_ACK [i])
+            {
               Tcontext_t context = (_param->_have_port_context_id)?PORT_READ(in_BRANCH_COMPLETE_CONTEXT_ID [i]):0;
               Tdepth_t   depth   = (_param->_have_port_max_depth     )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
               log_printf(TRACE,Update_Prediction_Table,FUNCTION,"BRANCH_COMPLETE[%d] - Accepted",i);
               log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
               log_printf(TRACE,Update_Prediction_Table,FUNCTION," * depth   : %d",depth);
               log_printf(TRACE,Update_Prediction_Table,FUNCTION," * nb_elt  : %d",reg_NB_ELT[context]);
+              Tdepth_t   depth   = (_param->_have_port_depth     )?PORT_READ(in_BRANCH_COMPLETE_DEPTH      [i]):0;
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * BRANCH_COMPLETE[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * miss    : %d",internal_BRANCH_COMPLETE_MISS_PREDICTION [i]);
               if (internal_BRANCH_COMPLETE_MISS_PREDICTION [i])
+                {
                   // Miss case
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_EVENT;
+                  // Another prediction (prediction with depth higer)
+                  Tdepth_t top                = reg_TOP [context];
+                  uint32_t nb_elt_miss        = ((top> depth)?top:(top+_param->_size_queue[context]))-depth;
+                  uint32_t nb_elt_need_update = 1;
+                  for (uint32_t j=1; j<nb_elt_miss; j++)
+                    {
+                      uint32_t k=(depth+j)%_param->_size_queue[context];
+// //                breakpoint("Branch_complete and miss ...");
+//                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state [%d][%d] <- UPDATE_PREDICTION_STATE_EVENT (branch_complete)",context,depth);
+//                reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_EVENT;
+//                // Another prediction (prediction with depth higer)
+//                Tdepth_t top                = reg_TOP [context];
+//                uint32_t nb_elt_miss        = ((top> depth)?top:(top+_param->_size_queue[context]))-depth;
+//                uint32_t nb_elt_need_update = 1;
+//                for (uint32_t j=1; j<nb_elt_miss; j++)
+//                  {
+//                    uint32_t k=(depth+j)%_param->_size_queue[context];
+                      // Ifetch have make a prediction and it's a miss
+                      // When ifetch predict :
+                      //   * btb is not change       -> needn't update
+                      //   * direction is not change -> needn't update
+                      //   * ras have change         -> need    update
+                      Tbranch_condition_t cond = reg_UPDATE_PREDICTION_TABLE [context][k]._condition;
+                      if ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or
+                          (cond == BRANCH_CONDITION_READ_STACK))
+                        {
+                          nb_elt_need_update ++;
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_KO;
+                        }
+                      else
+                        {
+                          reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_END;
+                        }
+                    }
+                  reg_NB_ELT_NEED_UPDATE [context] += nb_elt_need_update;
+                  // Update pointer :
+                  reg_TOP                [context]  = depth;
+                  reg_NB_ELT             [context] -= nb_elt_miss;
+//                    // Ifetch have make a prediction and it's a miss
+//                    // When ifetch predict :
+//                    //   * btb is not change       -> needn't update
+//                    //   * direction is not change -> needn't update
+//                    //   * ras have change         -> need    update
+//                    Tbranch_condition_t cond = reg_UPDATE_PREDICTION_TABLE [context][k]._condition;
+//                    if ((cond == BRANCH_CONDITION_NONE_WITH_WRITE_STACK) or
+//                        (cond == BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK) or
+//                        (cond == BRANCH_CONDITION_READ_STACK))
+//                      {
+//                           log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state [%d][%d] <- UPDATE_PREDICTION_STATE_KO (branch_complete, ifetch miss, update ras)",context,k);
+//                        nb_elt_need_update ++;
+//                        reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_KO;
+//                      }
+//                    else
+//                      {
+//                           log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state [%d][%d] <- UPDATE_PREDICTION_STATE_END (branch_complete, ifetch miss, don't update ras)",context,k);
+//                        reg_UPDATE_PREDICTION_TABLE [context][k]._state = UPDATE_PREDICTION_STATE_END;
+//                      }
+//                  }
+//                reg_NB_ELT_NEED_UPDATE [context] += nb_elt_need_update;
+//                // Update pointer :
+//                reg_TOP                [context]  = depth;
+//                reg_NB_ELT             [context] -= nb_elt_miss;
+//            reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest = internal_BRANCH_COMPLETE_ADDRESS_DEST [i];
+                }
               else
+                {
+                  // Hit case
+#ifdef DEBUG_TEST
+                  if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_WAITEND)
+                    ERRORMORPHEO(FUNCTION,"Branche complete : invalid state");
+#endif
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_OK;
+                  // Hit case
+#ifdef DEBUG_TEST
+                  if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_WAIT_END)
+                    throw ERRORMORPHEO(FUNCTION,_("Branch complete : invalid upt state."));
+#endif
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_OK (branch_complete, ifetch hit)",context,depth);
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_OK;
+                }
+              // In all case : update good_take and address_destination
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take    = internal_BRANCH_COMPLETE_TAKE         [i];
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._address_dest = internal_BRANCH_COMPLETE_ADDRESS_DEST [i];
+            }
+              // In all case : update good_take
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._good_take = internal_BRANCH_COMPLETE_TAKE [i];
+            }
         // ===================================================================
 …
         // ===================================================================
         for (uint32_t i=0; i<_param->_nb_inst_update; i++)
+          if (internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i]))
+          if ((internal_UPDATE_VAL[i] and PORT_READ(in_UPDATE_ACK [i])) or
+              (internal_UPDATE_VAL_WITHOUT_ACK [i]))
+            {
               Tcontext_t context = internal_UPDATE_CONTEXT_ID [i];
               Tdepth_t   depth   = internal_UPDATE_DEPTH      [i];
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"UPDATE[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION," * depth   : %d",depth);
+              if (reg_UPDATE_PREDICTION_TABLE [context][depth]._state == UPDATE_PREDICTION_STATE_KO)
+                reg_NB_ELT_NEED_UPDATE [context] --;
+              reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END;
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * UPDATE[%d] - Accepted",i);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * context : %d",context);
+              log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * depth   : %d",depth);
+              if (internal_UPDATE_FROM_UFPT [i])
+                {
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Fetch Prediction Table");
+                  // Change state
+#ifdef DEBUG_TEST
+                  if (reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state != UPDATE_FETCH_PREDICTION_STATE_EVENT)
+                    throw ERRORMORPHEO(FUNCTION,_("Update : invalid ufpt state."));
+#endif
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UFPT [%d][%d].state <- UPDATE_FETCH_PREDICTION_STATE_END (update)",context,depth);
+                  reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._state = UPDATE_FETCH_PREDICTION_STATE_END;
+                  // Update pointer
+                  reg_UFPT_UPDATE [context] = (depth==0)?(_param->_size_ufpt_queue[context]-1):(depth-1);
+                  // Free a register that need update ?
+                  if (need_update(reg_UPDATE_FETCH_PREDICTION_TABLE [context][depth]._condition))
+                    reg_UFPT_NB_NEED_UPDATE [context] --;
+                }
+              else
+                {
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update Prediction Table");
+                  // Change state
+#ifdef DEBUG_TEST
+                  if ((reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_OK   ) and
+                      (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_KO   ) and
+                      (reg_UPDATE_PREDICTION_TABLE [context][depth]._state != UPDATE_PREDICTION_STATE_EVENT))
+                    throw ERRORMORPHEO(FUNCTION,_("Update : invalid upt state."));
+#endif
+                  log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * UPT  [%d][%d].state <- UPDATE_PREDICTION_STATE_END (update)",context,depth);
+                  reg_UPDATE_PREDICTION_TABLE [context][depth]._state = UPDATE_PREDICTION_STATE_END;
+                  // Update pointer
+                  if (internal_UPDATE_RAS [i])
+                    reg_UPT_UPDATE [context] = (depth==0)?(_param->_size_upt_queue[context]-1):(depth-1);
+                  else
+                    reg_UPT_UPDATE [context] = (depth+1)%_param->_size_upt_queue[context];
+                  // Free a register that need update ?
+                  if (need_update(reg_UPDATE_PREDICTION_TABLE [context][depth]._condition))
+                    reg_UPT_NB_NEED_UPDATE [context] --;
+                  // Free the branch with no accurate ?
+                  if (reg_UPDATE_PREDICTION_TABLE [context][depth]._is_accurate == false)
+                    reg_IS_ACCURATE [i] = true;
+                }
+            }
 …
         reg_UPDATE_PRIORITY = (reg_UPDATE_PRIORITY+1)%_param->_nb_context;
+        // ===================================================================
+        // =====[ BRANCH_EVENT ]==============================================
+        // ===================================================================
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          if (internal_BRANCH_EVENT_VAL [i] and PORT_READ(in_BRANCH_EVENT_ACK [i]))
+          {
+            Tdepth_t depth = internal_BRANCH_EVENT_DEPTH [i];
+            reg_UPDATE_PREDICTION_TABLE [i][depth]._state = UPDATE_PREDICTION_STATE_KO;
+          }
+        // ===================================================================
+        // =====[ GARBAGE COLLECTOR ]=========================================
+        // ===================================================================
+        for (uint32_t i=0; i<_param->_nb_context; i++)
+          {
+            uint32_t bottom = reg_BOTTOM [i];
+            // Test if the tail of queue is finish (ok or ko and update)
+            if (reg_UPDATE_PREDICTION_TABLE [i][bottom]._state == UPDATE_PREDICTION_STATE_END)
+              {
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION,"GARBAGE_COLLECTOR");
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION," * context : %d",i);
+                log_printf(TRACE,Update_Prediction_Table,FUNCTION," * bottom  : %d",bottom);
+                reg_UPDATE_PREDICTION_TABLE [i][bottom]._state = UPDATE_PREDICTION_STATE_EMPTY;
+                reg_BOTTOM [i] = (bottom+1)%_param->_size_queue [i];
+                if (reg_NB_ELT [i]>0)
+                  reg_NB_ELT [i] --;
+              }
+          }
+      }
+//      // ===================================================================
+//      // =====[ BRANCH_EVENT ]==============================================
+//      // ===================================================================
+//      for (uint32_t i=0; i<_param->_nb_context; i++)
+//        if (internal_BRANCH_EVENT_VAL [i] and PORT_READ(in_BRANCH_EVENT_ACK [i]))
+//             {
+//               Tdepth_t depth = internal_BRANCH_EVENT_DEPTH [i];
+//               if (reg_UPDATE_PREDICTION_TABLE [i][depth]._state == UPDATE_PREDICTION_STATE_EVENT)
+//                 {
+//                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state [%d][%d] <- UPDATE_PREDICTION_STATE_KO (branch_event)",i,depth);
+//                   reg_UPDATE_PREDICTION_TABLE [i][depth]._state = UPDATE_PREDICTION_STATE_KO;
+//                 }
+//               else
+//                 {
+// #ifdef DEBUG_TEST
+//                   if (reg_UPDATE_PREDICTION_TABLE [i][depth]._state == UPDATE_PREDICTION_STATE_WAITEND_AND_EVENT)
+//                     throw ERRORMORPHEO(FUNCTION,_("Branche event : invalid state"));
+// #endif
+//                   log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * state [%d][%d] <- UPDATE_PREDICTION_STATE_WAITEND (branch_event)",i,depth);
+//                   reg_UPDATE_PREDICTION_TABLE [i][depth]._state = UPDATE_PREDICTION_STATE_WAITEND;
+//                 }
+//             }
 #if (DEBUG >= DEBUG_TRACE)
     log_printf(TRACE,Update_Prediction_Table,FUNCTION,"Dump Update_Prediction_Table");
     log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * reg_UPDATE_PRIORITY      : %d",reg_UPDATE_PRIORITY);
+    log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * Dump Update_Prediction_Table");
+    log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_UPDATE_PRIORITY       : %d",reg_UPDATE_PRIORITY);
     for (uint32_t i=0; i<_param->_nb_context; i++)
+      {
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"  * Update_Prediction_Table   [%d]",i);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_TOP                : %d",reg_TOP                [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_BOTTOM             : %d",reg_BOTTOM             [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_NB_ELT             : %d",reg_NB_ELT             [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_NB_ELT_NEED_UPDATE : %d",reg_NB_ELT_NEED_UPDATE [i]);
+        for (uint32_t j=0; j<_param->_size_queue[i]; j++)
+          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      [%d] %s %x",j,toString(reg_UPDATE_PREDICTION_TABLE [i][j]._state).c_str(),reg_UPDATE_PREDICTION_TABLE [i][j]._address_src);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_IS_ACCURATE           : %d",reg_IS_ACCURATE        [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_EVENT_STATE           : %s"  ,toString(reg_EVENT_STATE [i]).c_str());
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_EVENT_RAS_CORRUPTED   : %d"  ,reg_EVENT_RAS_CORRUPTED   [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_EVENT_ADDRESS_SRC     : %.8x",reg_EVENT_ADDRESS_SRC     [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_EVENT_ADDRESS_SRC_VAL : %d"  ,reg_EVENT_ADDRESS_SRC_VAL [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * reg_EVENT_ADDRESS_DEST    : %.8x",reg_EVENT_ADDRESS_DEST    [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update_Fetch_Prediction_Table   [%d]",i);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UFPT_BOTTOM         : %d",reg_UFPT_BOTTOM         [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UFPT_TOP            : %d",reg_UFPT_TOP            [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UFPT_NB_NEED_UPDATE : %d",reg_UFPT_NB_NEED_UPDATE [i]);
+        for (uint32_t j=0; j<_param->_size_ufpt_queue[i]; j++)
+          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"        [%d] %.4d, %.8x %.8x, %.1d   %.1d, %.8d %.8x %.4d - %s",
+                     j,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._condition,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._address_src,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._address_dest,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._last_take,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._is_accurate,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._history,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._address_ras,
+                     reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._index_ras,
+                     toString(reg_UPDATE_FETCH_PREDICTION_TABLE [i][j]._state).c_str()
+                     );
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"    * Update_Prediction_Table   [%d]",i);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_BOTTOM          : %d",reg_UPT_BOTTOM         [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_TOP             : %d",reg_UPT_TOP            [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_UPDATE          : %d",reg_UPT_UPDATE         [i]);
+        log_printf(TRACE,Update_Prediction_Table,FUNCTION,"      * reg_UPT_NB_NEED_UPDATE  : %d",reg_UPT_NB_NEED_UPDATE [i]);
+        for (uint32_t j=0; j<_param->_size_upt_queue[i]; j++)
+          log_printf(TRACE,Update_Prediction_Table,FUNCTION,"        [%d] %.4d, %.8x %.8x, %.1d %.1d %.1d, %.8d %.8x %.4d - %s",
+                     j,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._condition,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._address_src,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._address_dest,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._last_take,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._good_take,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._is_accurate,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._history,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._address_ras,
+                     reg_UPDATE_PREDICTION_TABLE [i][j]._index_ras,
+                     toString(reg_UPDATE_PREDICTION_TABLE [i][j]._state).c_str()
+                     );
+      }
 #endif
+      }
 …
     end_cycle ();
 #endif
     log_printf(FUNC,Update_Prediction_Table,FUNCTION,"End");
+    log_end(Update_Prediction_Table,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/include/Parameters.h

-              r82
+              r88
   public : uint32_t *   _upt_size_queue                ;//[nb_context]
   public : uint32_t     _size_context_id               ;
+  public : uint32_t *   _size_depth                    ;//[nb_context]
+  public : uint32_t     _max_size_depth                ;
   public : uint32_t *   _size_inst_ifetch_ptr          ;//[nb_context]
+//public : uint32_t     _size_context_id               ;
+//public : uint32_t     _max_size_depth                ;
+//public : uint32_t *   _size_inst_ifetch_ptr          ;//[nb_context]
+  public : uint32_t *   _array_size_depth              ;//[nb_context]
   public : uint32_t     _size_history                  ;
   public : uint32_t *   _size_ras_index                ;//[nb_context]
   public : bool         _have_port_context_id          ;
   public : bool         _have_port_max_depth           ;
   public : bool     *   _have_port_depth               ;//[nb_context]
   public : bool     *   _have_port_inst_ifetch_ptr     ;//[nb_context]
+//public : bool         _have_port_context_id          ;
+//public : bool         _have_port_max_depth           ;
+//public : bool     *   _have_port_depth               ;//[nb_context]
+//public : bool     *   _have_port_inst_ifetch_ptr     ;//[nb_context]
   public : bool         _have_port_history             ;
   public : bool     *   _have_port_ras_index           ;//[nb_context]
 …
                         uint32_t     dir_pht_size_address_share [3],
                         uint32_t *   ras_size_queue                ,//[nb_context]
+                        uint32_t *   upt_size_queue                 //[nb_context]
+                        uint32_t *   upt_size_queue                ,//[nb_context]
+                        bool         is_toplevel=false
                         );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/include/Prediction_unit.h

-              r82
+              r88
     // ~~~~~[ Interface : "depth" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_NB_BRANCH                     ; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_TAIL                          ; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_CURRENT                       ; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_MIN                           ; //[nb_context]
+  public    : SC_OUT(Tdepth_t           )  ** out_DEPTH_MAX                           ; //[nb_context]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Parameters.cpp

-              r82
+              r88
                           uint32_t     dir_pht_size_address_share [3],
                           uint32_t *   ras_size_queue                ,//[nb_context]
+                          uint32_t *   upt_size_queue                 //[nb_context]
+                          uint32_t *   upt_size_queue                ,//[nb_context]
+                          bool         is_toplevel
+                          )
+  {
 …
     _ras_size_queue             = ras_size_queue            ;
     _upt_size_queue             = upt_size_queue            ;
+    _size_context_id            = log2(_nb_context);
+//   public : uint32_t *   _size_inst_ifetch_ptr          ;//[nb_context]
+    _size_depth                 = new uint32_t [_nb_context];
+    _array_size_depth           = new uint32_t [_nb_context];
     _size_ras_index             = new uint32_t [_nb_context];
     for (uint32_t i=0; i<_nb_context; i++)
+      {
         _size_depth     [i] = log2(_upt_size_queue [i]);
         _size_ras_index [i] = log2(_ras_size_queue [i]);
+        _array_size_depth [i] = log2(_upt_size_queue [i]);
+        _size_ras_index   [i] = log2(_ras_size_queue [i]);
+      }
-    _max_size_depth             = max<uint32_t>(_size_depth,_nb_context);
-    _have_port_context_id       = (_size_context_id > 0);
-    _have_port_max_depth        = (_max_size_depth  > 0);
-//   public : bool     *   _have_port_inst_ifetch_ptr     ;//[nb_context]
     _param_glue = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::prediction_unit_glue   ::Parameters
 …
        _size_address          ,
        _nb_instruction        ,
        _size_depth            ,
+       _array_size_depth      ,
        _nb_inst_decod         ,
        _nb_inst_branch_predict,
 …
        _nb_inst_branch_update );
-    _size_inst_ifetch_ptr      = _param_glue->_size_inst_ifetch_ptr     ;
-    _have_port_depth           = _param_glue->_have_port_depth;
-    _have_port_inst_ifetch_ptr = _param_glue->_have_port_inst_ifetch_ptr;
-    _have_port_history         = (_size_history > 0);
     _param_btb  = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::branch_target_buffer   ::Parameters
       (_nb_context            ,
 …
        _nb_inst_branch_update ,
        _btb_victim_scheme     );
     _param_dir  = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::direction              ::Parameters
       (_dir_predictor_scheme      ,
 …
        _dir_pht_size_address_share);
+    _size_history = _param_dir->_size_history;
+    _size_history      = _param_dir->_size_history;
+    _have_port_history = (_size_history > 0);
     _param_ras  = new morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::return_address_stack   ::Parameters
 …
        _size_history           ,
        _size_ras_index         );
+    if (is_toplevel)
+      {
+        _size_context_id           = log2(_nb_context);
+        _size_depth                = max<uint32_t>(_array_size_depth,_nb_context);
+        _size_inst_ifetch_ptr      = log2(max<uint32_t>(_nb_instruction,_nb_context));
+        _size_instruction_address  = size_address;
+//      _size_nb_inst_decod        = ;
+//      _size_nb_inst_commit       = ;
+//      _size_ifetch_queue_ptr     = ;
+        _have_port_context_id      = (_size_context_id > 0);
+        _have_port_depth           = (_size_depth  > 0);
+        _have_port_inst_ifetch_ptr = _size_inst_ifetch_ptr > 0;
+//      _have_port_ifetch_queue_ptr= _size_ifetch_queue_ptr > 0;
+        copy ();
+      }
     test();
 …
     delete _param_glue;
     delete [] _size_depth    ;
+    delete [] _array_size_depth;
     delete [] _size_ras_index;
+    log_printf(FUNC,Prediction_unit,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Prediction_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Prediction_unit,FUNCTION,"Begin");
+    COPY(_param_btb );
+    COPY(_param_dir );
+    COPY(_param_ras );
+    COPY(_param_upt );
+    COPY(_param_glue);
     log_printf(FUNC,Prediction_unit,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Prediction_unit,FUNCTION,"Begin");
+#if DEBUG_Prediction_unit == true
+    log_printf(INFO,Prediction_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Prediction_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Prediction_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Prediction_unit,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit_allocation.cpp

-              r82
+              r88
         ALLOC1_SIGNAL_OUT(out_PREDICT_PC_NEXT                    ,"pc_next"                    ,Taddress_t         ,_param->_size_address);
         ALLOC1_SIGNAL_OUT(out_PREDICT_PC_NEXT_IS_DS_TAKE         ,"pc_next_is_ds_take"         ,Tcontrol_t         ,1);
         ALLOC1_SIGNAL_OUT(out_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr [alloc_signal_it1]);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr);
         ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state);
         ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth [alloc_signal_it1]);
+        ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth);
+      }
+      {
         ALLOC2_INTERFACE("predict",IN,SOUTH,"Interface with ifetch unit",_param->_nb_context,_param->_nb_instruction[alloc_interface_it1]);
         _ALLOC2_SIGNAL_OUT(out_PREDICT_INSTRUCTION_ENABLE         ,"instruction_enable"         ,Tcontrol_t         ,1,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1]);
+        ALLOC2_INTERFACE("predict",IN,SOUTH,"Interface with ifetch unit",_param->_nb_context,_param->_nb_instruction[it1]);
+        _ALLOC2_SIGNAL_OUT(out_PREDICT_INSTRUCTION_ENABLE         ,"instruction_enable"         ,Tcontrol_t         ,1,_param->_nb_context,_param->_nb_instruction[it1]);
+      }
+    }
 …
+    {
+      {
         ALLOC2_INTERFACE("decod",IN,SOUTH,"Interface with decod unit",_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_interface_it1]);
+        ALLOC2_INTERFACE("decod",IN,SOUTH,"Interface with decod unit",_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
         _ALLOC2_VALACK_IN ( in_DECOD_VAL                        ,VAL,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_VALACK_OUT(out_DECOD_ACK                        ,ACK,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_max_size_depth       ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_SRC                ,"address_src"                ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
         _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_DEST               ,"address_dest"               ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1]);
+        _ALLOC2_VALACK_IN ( in_DECOD_VAL                        ,VAL,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_VALACK_OUT(out_DECOD_ACK                        ,ACK,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_SRC                ,"address_src"                ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+        _ALLOC2_SIGNAL_IN ( in_DECOD_ADDRESS_DEST               ,"address_dest"               ,Taddress_t         ,_param->_size_address         ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1]);
+      }
+    }
 …
       ALLOC1_VALACK_OUT(out_BRANCH_COMPLETE_ACK            ,ACK);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_max_size_depth);
+      ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_size_depth);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_ADDRESS        ,"address"        ,Taddress_t,_param->_size_address);
       ALLOC1_SIGNAL_IN ( in_BRANCH_COMPLETE_FLAG           ,"flag"           ,Tcontrol_t,1);
 …
       ALLOC1_VALACK_IN ( in_BRANCH_EVENT_ACK            ,ACK);
 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_CONTEXT_ID     ,"context_id"     ,Tcontext_t,_param->_size_context_id);
 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_max_size_depth);
+//    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_DEPTH          ,"depth"          ,Tdepth_t  ,_param->_size_depth);
 //    ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_MISS_PREDICTION,"miss_prediction",Tcontrol_t,1);
       ALLOC1_SIGNAL_OUT(out_BRANCH_EVENT_ADDRESS_SRC    ,"address_src"    ,Taddress_t,_param->_size_address);
 …
       ALLOC1_INTERFACE("depth",OUT,SOUTH,"Interface with depth",_param->_nb_context);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_NB_BRANCH    ,"nb_branch"    ,Tdepth_t,_param->_size_depth[alloc_signal_it1]+1);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_TAIL         ,"tail"         ,Tdepth_t,_param->_size_depth[alloc_signal_it1]);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_CURRENT      ,"current"      ,Tdepth_t,_param->_size_depth);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_MIN          ,"min"          ,Tdepth_t,_param->_size_depth);
+      ALLOC1_SIGNAL_OUT(out_DEPTH_MAX          ,"max"          ,Tdepth_t,_param->_size_depth+1);
+    }
 …
           COMPONENT_MAP(_component,src , "in_PREDICT_"    +toString(i)+"_CONTEXT_ID"      ,
                                    dest,"out_PREDICT_UPT_"+toString(i)+"_CONTEXT_ID"      );
+          if (_param->_have_port_depth)
+          COMPONENT_MAP(_component,src ,"out_PREDICT_"    +toString(i)+       "_UPDATE_PREDICTION_ID",
+                                   dest, "in_PREDICT_UPT_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID");
           COMPONENT_MAP(_component,src , "in_PREDICT_"    +toString(i)+"_BTB_ADDRESS_SRC" ,
                                    dest,"out_PREDICT_UPT_"+toString(i)+"_BTB_ADDRESS_SRC" );
 …
           COMPONENT_MAP(_component,src , "in_DECOD_"    +toString(i)+"_MISS_DECOD"          ,
                                    dest,"out_DECOD_UPT_"+toString(i)+"_MISS_DECOD"          );
           if (_param->_have_port_max_depth)
+          if (_param->_have_port_depth)
           COMPONENT_MAP(_component,src , "in_DECOD_"    +toString(i)+"_UPDATE_PREDICTION_ID",
                                    dest,"out_DECOD_UPT_"+toString(i)+"_UPDATE_PREDICTION_ID");
+          COMPONENT_MAP(_component,src , "in_DECOD_"    +toString(i)+"_IS_ACCURATE"         ,
+                                   dest,"out_DECOD_UPT_"+toString(i)+"_IS_ACCURATE"         );
           //out_DECOD_UPT_RAS_INDEX - component_map return_address_stack
 …
           PORT_MAP(_component,src , "in_BRANCH_COMPLETE_"+toString(i)+"_CONTEXT_ID"     ,
                               dest, "in_BRANCH_COMPLETE_"+toString(i)+"_CONTEXT_ID"     );
           if (_param->_have_port_max_depth)
+          if (_param->_have_port_depth)
           PORT_MAP(_component,src , "in_BRANCH_COMPLETE_"+toString(i)+"_DEPTH"          ,
                               dest, "in_BRANCH_COMPLETE_"+toString(i)+"_DEPTH"          );
 …
       for (uint32_t i=0; i<_param->_nb_context; i++)
+        {
+          dest = _name+"_prediction_unit_glue";
+          dest = _name;
 #ifdef POSITION
           _component->interface_map (src ,"depth_"+toString(i),
 …
 #endif
+          COMPONENT_MAP(_component,src ,"out_DEPTH_"+toString(i)+    "_NB_BRANCH",
+                                   dest, "in_DEPTH_"+toString(i)+"_UPT_NB_BRANCH");
+          if (_param->_have_port_depth[i])
+          COMPONENT_MAP(_component,src ,"out_DEPTH_"+toString(i)+    "_TAIL"     ,
+                                   dest, "in_DEPTH_"+toString(i)+"_UPT_TAIL"     );
+        }
+          if (_param->_have_port_depth)
+            {
+          PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_CURRENT",
+                              dest,"out_DEPTH_"+toString(i)+"_CURRENT");
+          PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_MIN",
+                              dest,"out_DEPTH_"+toString(i)+"_MIN");
+            }
+          PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_MAX",
+                              dest,"out_DEPTH_"+toString(i)+"_MAX");
+        }
+//       for (uint32_t i=0; i<_param->_nb_context; i++)
+//      {
+//        dest = _name+"_prediction_unit_glue";
+// #ifdef POSITION
+//        _component->interface_map (src ,"depth_"+toString(i),
+//                                   dest,"depth_"+toString(i));
+// #endif
+//        COMPONENT_MAP(_component,src ,"out_DEPTH_"+toString(i)+    "_NB_BRANCH",
+//                                 dest, "in_DEPTH_"+toString(i)+"_UPT_NB_BRANCH");
+//        if (_param->_have_port_depth)
+//        COMPONENT_MAP(_component,src ,"out_DEPTH_"+toString(i)+    "_TAIL"     ,
+//                                 dest, "in_DEPTH_"+toString(i)+"_UPT_TAIL"     );
+//      }
+    }
 …
           PORT_MAP(_component,src ,"out_PREDICT_"+toString(i)+"_PC_NEXT_IS_DS_TAKE"         ,
                               dest,"out_PREDICT_"+toString(i)+"_PC_NEXT_IS_DS_TAKE"         );
           if (_param->_have_port_inst_ifetch_ptr [i])
+          if (_param->_have_port_inst_ifetch_ptr)
           PORT_MAP(_component,src ,"out_PREDICT_"+toString(i)+"_INST_IFETCH_PTR"            ,
                               dest,"out_PREDICT_"+toString(i)+"_INST_IFETCH_PTR"            );
           PORT_MAP(_component,src ,"out_PREDICT_"+toString(i)+"_BRANCH_STATE"               ,
                               dest,"out_PREDICT_"+toString(i)+"_BRANCH_STATE"               );
           if (_param->_have_port_depth [i])
+          if (_param->_have_port_depth)
           PORT_MAP(_component,src ,"out_PREDICT_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID",
                               dest,"out_PREDICT_"+toString(i)+"_BRANCH_UPDATE_PREDICTION_ID");
 …
             PORT_MAP(_component,src , "in_DECOD_"+toString(i)+"_"+toString(j)+"_BRANCH_STATE"               ,
                                 dest, "in_DECOD_"+toString(i)+"_"+toString(j)+"_BRANCH_STATE"               );
             if (_param->_have_port_max_depth)
+            if (_param->_have_port_depth)
             PORT_MAP(_component,src , "in_DECOD_"+toString(i)+"_"+toString(j)+"_BRANCH_UPDATE_PREDICTION_ID",
                                 dest, "in_DECOD_"+toString(i)+"_"+toString(j)+"_BRANCH_UPDATE_PREDICTION_ID");
 …
+          }
       for (uint32_t i=0; i<_param->_nb_context; i++)
+        {
           dest = _name;
 #ifdef POSITION
           _component->interface_map (src ,"depth_"+toString(i),
                                      dest,"depth_"+toString(i));
 #endif
           PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_NB_BRANCH",dest,"out_DEPTH_"+toString(i)+"_NB_BRANCH");
           if (_param->_have_port_depth[i])
           PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_TAIL"     ,dest,"out_DEPTH_"+toString(i)+"_TAIL"     );
+        }
+//       for (uint32_t i=0; i<_param->_nb_context; i++)
+//      {
+//        dest = _name;
+// #ifdef POSITION
+//        _component->interface_map (src ,"depth_"+toString(i),
+//                                   dest,"depth_"+toString(i));
+// #endif
+//        PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_NB_BRANCH",dest,"out_DEPTH_"+toString(i)+"_NB_BRANCH");
+//        if (_param->_have_port_depth)
+//        PORT_MAP(_component,src ,"out_DEPTH_"+toString(i)+"_TAIL"     ,dest,"out_DEPTH_"+toString(i)+"_TAIL"     );
+//      }
+    }
     // ~~~~~[ Others ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    _component->test_map(false);
+#ifdef POSITION
+    _component->generate_file();
+#if DEBUG_Prediction_unit == true
+    _component->test_map();
+#endif
+#ifdef POSITION
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit_deallocation.cpp

-              r82
+              r88
     log_printf(FUNC,Prediction_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         DELETE1_SIGNAL( in_PREDICT_VAL                        ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_PREDICT_ACK                        ,_param->_nb_context,1);
         DELETE1_SIGNAL( in_PREDICT_PC_PREVIOUS                ,_param->_nb_context,_param->_size_address);
         DELETE1_SIGNAL( in_PREDICT_PC_CURRENT                 ,_param->_nb_context,_param->_size_address);
+        DELETE1_SIGNAL( in_PREDICT_PC_PREVIOUS                ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL( in_PREDICT_PC_CURRENT                 ,_param->_nb_context,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_PREDICT_PC_CURRENT_IS_DS_TAKE      ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_PREDICT_PC_NEXT                    ,_param->_nb_context,_param->_size_address);
+        DELETE1_SIGNAL(out_PREDICT_PC_NEXT                    ,_param->_nb_context,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_PREDICT_PC_NEXT_IS_DS_TAKE         ,_param->_nb_context,1);
         DELETE1_SIGNAL(out_PREDICT_INST_IFETCH_PTR            ,_param->_nb_context,_param->_size_inst_ifetch_ptr [alloc_signal_it1]);
+        DELETE1_SIGNAL(out_PREDICT_INST_IFETCH_PTR            ,_param->_nb_context,_param->_size_inst_ifetch_ptr);
         DELETE1_SIGNAL(out_PREDICT_BRANCH_STATE               ,_param->_nb_context,_param->_size_branch_state);
         DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context,_param->_size_depth [alloc_signal_it1]);
+        DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_context,_param->_size_depth );
         DELETE2_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE       ,_param->_nb_context,_param->_nb_instruction[alloc_signal_it1],1);
         DELETE2_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1);
         DELETE2_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1);
         DELETE2_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_context_id      );
         DELETE2_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1                             );
         DELETE2_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_branch_state    );
         DELETE2_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_max_size_depth       );
         DELETE2_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_branch_condition);
         DELETE2_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],1                             );
         DELETE2_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_address         );
         DELETE2_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[alloc_signal_it1],_param->_size_address         );
+        DELETE2_SIGNAL(out_PREDICT_INSTRUCTION_ENABLE       ,_param->_nb_context,_param->_nb_instruction[it1],1);
+        DELETE2_SIGNAL( in_DECOD_VAL                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1);
+        DELETE2_SIGNAL(out_DECOD_ACK                        ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1);
+        DELETE2_SIGNAL( in_DECOD_CONTEXT_ID                 ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_context_id      );
+        DELETE2_SIGNAL( in_DECOD_MATCH_INST_IFETCH_PTR      ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1                             );
+        DELETE2_SIGNAL( in_DECOD_BRANCH_STATE               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_branch_state    );
+        DELETE2_SIGNAL( in_DECOD_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_depth           );
+        DELETE2_SIGNAL( in_DECOD_BRANCH_CONDITION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_branch_condition);
+        DELETE2_SIGNAL( in_DECOD_BRANCH_DIRECTION           ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],1                             );
+        DELETE2_SIGNAL( in_DECOD_ADDRESS_SRC                ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_instruction_address         );
+        DELETE2_SIGNAL( in_DECOD_ADDRESS_DEST               ,_param->_nb_decod_unit,_param->_nb_inst_decod[it1],_param->_size_instruction_address         );
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_VAL            ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL(out_BRANCH_COMPLETE_ACK            ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_CONTEXT_ID     ,_param->_nb_inst_branch_complete,_param->_size_context_id);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_DEPTH          ,_param->_nb_inst_branch_complete,_param->_max_size_depth);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_ADDRESS        ,_param->_nb_inst_branch_complete,_param->_size_address);
+        DELETE1_SIGNAL( in_BRANCH_COMPLETE_DEPTH          ,_param->_nb_inst_branch_complete,_param->_size_depth);
+        DELETE1_SIGNAL( in_BRANCH_COMPLETE_ADDRESS        ,_param->_nb_inst_branch_complete,_param->_size_instruction_address);
         DELETE1_SIGNAL( in_BRANCH_COMPLETE_FLAG           ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL(out_BRANCH_COMPLETE_MISS_PREDICTION,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL(out_BRANCH_COMPLETE_TAKE           ,_param->_nb_inst_branch_complete,1);
         DELETE1_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_SRC    ,_param->_nb_inst_branch_complete,_param->_size_address);
         DELETE1_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete,_param->_size_address);
+        DELETE1_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_SRC    ,_param->_nb_inst_branch_complete,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_BRANCH_COMPLETE_ADDRESS_DEST   ,_param->_nb_inst_branch_complete,_param->_size_instruction_address);
         DELETE1_SIGNAL(out_BRANCH_EVENT_VAL            ,_param->_nb_context,1);
         DELETE1_SIGNAL( in_BRANCH_EVENT_ACK            ,_param->_nb_context,1);
 //      DELETE1_SIGNAL(out_BRANCH_EVENT_CONTEXT_ID     ,_param->_nb_context,_param->_size_context_id);
 //      DELETE1_SIGNAL(out_BRANCH_EVENT_DEPTH          ,_param->_nb_context,_param->_max_size_depth);
+//      DELETE1_SIGNAL(out_BRANCH_EVENT_DEPTH          ,_param->_nb_context,_param->_size_depth);
 //      DELETE1_SIGNAL(out_BRANCH_EVENT_MISS_PREDICTION,_param->_nb_context,1);
         DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC    ,_param->_nb_context,_param->_size_address);
         DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST   ,_param->_nb_context,_param->_size_address);
+        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_SRC    ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_BRANCH_EVENT_ADDRESS_DEST   ,_param->_nb_context,_param->_size_instruction_address);
+        DELETE1_SIGNAL(out_DEPTH_NB_BRANCH    ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]+1);
+        DELETE1_SIGNAL(out_DEPTH_TAIL         ,_param->_nb_context,_param->_size_depth[alloc_signal_it1]);
+        DELETE1_SIGNAL(out_DEPTH_CURRENT      ,_param->_nb_context,_param->_size_depth);
+        DELETE1_SIGNAL(out_DEPTH_MIN          ,_param->_nb_context,_param->_size_depth);
+        DELETE1_SIGNAL(out_DEPTH_MAX          ,_param->_nb_context,_param->_size_depth+1);
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/src/Prediction_unit_statistics_allocation.cpp

-              r81
+              r88
                       "Prediction_unit",
                       param_statistics);
+    _stat->add_stat(_component_btb ->_stat);
+    _stat->add_stat(_component_dir ->_stat);
+    _stat->add_stat(_component_ras ->_stat);
+    _stat->add_stat(_component_upt ->_stat);
+    _stat->add_stat(_component_glue->_stat);
     log_printf(FUNC,Prediction_unit,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Load_Store_pointer_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/SelfTest/src/main.cpp

-              r81
+              r88
+    }
   uint32_t    _nb_load_store_queue              = atoi(argv[x++]);
+  uint32_t    _nb_load_store_queue              = fromString<uint32_t>(argv[x++]);
   if (argc != static_cast<int>(2+NB_PARAMS+_nb_front_end+2*_nb_load_store_queue+nb_thread))
 …
          _link_load_store_unit_with_thread,
          _nb_inst_insert                  ,
+         _nb_inst_retire                  );
+         _nb_inst_retire                  ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Load_Store_pointer_unit * _Load_Store_pointer_unit = new Load_Store_pointer_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC1_SC_SIGNAL( in_RETIRE_FRONT_END_ID         ," in_RETIRE_FRONT_END_ID         ",Tcontext_t  ,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_CONTEXT_ID           ," in_RETIRE_CONTEXT_ID           ",Tcontext_t  ,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL( in_RETIRE_TYPE                 ," in_RETIRE_TYPE                 ",Ttype_t     ,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL( in_RETIRE_OPERATION            ," in_RETIRE_OPERATION            ",Toperation_t,_param->_nb_inst_retire);
+//   ALLOC1_SC_SIGNAL( in_RETIRE_TYPE                 ," in_RETIRE_TYPE                 ",Ttype_t     ,_param->_nb_inst_retire);
+//   ALLOC1_SC_SIGNAL( in_RETIRE_OPERATION            ," in_RETIRE_OPERATION            ",Toperation_t,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL( in_RETIRE_USE_STORE_QUEUE      ," in_RETIRE_USE_STORE_QUEUE      ",Tcontrol_t  ,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL( in_RETIRE_USE_LOAD_QUEUE       ," in_RETIRE_USE_LOAD_QUEUE       ",Tcontrol_t  ,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_STORE_QUEUE_PTR_WRITE," in_RETIRE_STORE_QUEUE_PTR_WRITE",Tlsq_ptr_t  ,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_LOAD_QUEUE_PTR_WRITE ," in_RETIRE_LOAD_QUEUE_PTR_WRITE ",Tlsq_ptr_t  ,_param->_nb_inst_retire);
 …
   if (_param->_have_port_context_id)
   INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_CONTEXT_ID           ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_TYPE                 ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_OPERATION            ,_param->_nb_inst_retire);
+//   INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_TYPE                 ,_param->_nb_inst_retire);
+//   INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_OPERATION            ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_USE_STORE_QUEUE      ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_USE_LOAD_QUEUE       ,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Load_Store_pointer_unit, in_RETIRE_STORE_QUEUE_PTR_WRITE,_param->_nb_inst_retire);
   if (_param->_have_port_load_queue_ptr)
 …
               in_RETIRE_FRONT_END_ID          [i]->write(it->_front_end_id         );
               in_RETIRE_CONTEXT_ID            [i]->write(it->_context_id           );
+              in_RETIRE_TYPE                  [i]->write(it->_type                 );
+              in_RETIRE_OPERATION             [i]->write(it->_operation            );
+//            in_RETIRE_TYPE                  [i]->write(it->_type                 );
+//            in_RETIRE_OPERATION             [i]->write(it->_operation            );
+              in_RETIRE_USE_STORE_QUEUE       [i]->write((it->_type == TYPE_MEMORY) and     is_operation_memory_store(it->_operation));
+              in_RETIRE_USE_LOAD_QUEUE        [i]->write((it->_type == TYPE_MEMORY) and not is_operation_memory_store(it->_operation));
               in_RETIRE_STORE_QUEUE_PTR_WRITE [i]->write(it->_store_queue_ptr_write);
               in_RETIRE_LOAD_QUEUE_PTR_WRITE  [i]->write(it->_load_queue_ptr_write );
 …
           if (in_RETIRE_VAL[i]->read())
+            {
+              if (in_RETIRE_TYPE [i]->read() != TYPE_MEMORY)
+              if (not (in_RETIRE_USE_STORE_QUEUE [i]->read() or
+                       in_RETIRE_USE_LOAD_QUEUE  [i]->read()))
                 TEST(Tcontrol_t, out_RETIRE_ACK[i]->read(),true);
 …
   delete []  in_RETIRE_FRONT_END_ID         ;
   delete []  in_RETIRE_CONTEXT_ID           ;
+  delete []  in_RETIRE_TYPE                 ;
+  delete []  in_RETIRE_OPERATION            ;
+//   delete []  in_RETIRE_TYPE                 ;
+//   delete []  in_RETIRE_OPERATION            ;
+  delete []  in_RETIRE_USE_STORE_QUEUE      ;
+  delete []  in_RETIRE_USE_LOAD_QUEUE       ;
   delete []  in_RETIRE_STORE_QUEUE_PTR_WRITE;
   delete []  in_RETIRE_LOAD_QUEUE_PTR_WRITE ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/include/Load_Store_pointer_unit.h

-              r82
+              r88
   public    : SC_IN (Tcontext_t     )      **  in_RETIRE_FRONT_END_ID         ; // [nb_inst_retire]
   public    : SC_IN (Tcontext_t     )      **  in_RETIRE_CONTEXT_ID           ; // [nb_inst_retire]
+  public    : SC_IN (Ttype_t        )      **  in_RETIRE_TYPE                 ; // [nb_inst_retire]
+  public    : SC_IN (Toperation_t   )      **  in_RETIRE_OPERATION            ; // [nb_inst_retire]
+//public    : SC_IN (Ttype_t        )      **  in_RETIRE_TYPE                 ; // [nb_inst_retire]
+//public    : SC_IN (Toperation_t   )      **  in_RETIRE_OPERATION            ; // [nb_inst_retire]
+  public    : SC_IN (Tcontrol_t     )      **  in_RETIRE_USE_STORE_QUEUE      ; // [nb_inst_retire]
+  public    : SC_IN (Tcontrol_t     )      **  in_RETIRE_USE_LOAD_QUEUE       ; // [nb_inst_retire]
   public    : SC_IN (Tlsq_ptr_t     )      **  in_RETIRE_STORE_QUEUE_PTR_WRITE; // [nb_inst_retire]
   public    : SC_IN (Tlsq_ptr_t     )      **  in_RETIRE_LOAD_QUEUE_PTR_WRITE ; // [nb_inst_retire]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/include/Parameters.h

-              r82
+              r88
   public : uint32_t    _nb_inst_retire                  ;
   public : uint32_t    _size_front_end_id               ;
   public : uint32_t    _size_context_id                 ;
   public : uint32_t    _size_store_queue_ptr            ;
   public : uint32_t    _size_load_queue_ptr             ;
+//public : uint32_t    _size_front_end_id               ;
+//public : uint32_t    _size_context_id                 ;
+//public : uint32_t    _size_store_queue_ptr            ;
+//public : uint32_t    _size_load_queue_ptr             ;
   public : uint32_t    _have_port_front_end_id          ;
   public : uint32_t    _have_port_context_id            ;
   public : uint32_t    _have_port_load_queue_ptr        ;
+//public : uint32_t    _have_port_front_end_id          ;
+//public : uint32_t    _have_port_context_id            ;
+//public : uint32_t    _have_port_load_queue_ptr        ;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t    nb_front_end                    ,
                         uint32_t  * nb_context                      ,
+//                      uint32_t    size_front_end_id               ,
+//                      uint32_t    size_context_id                 ,
                         uint32_t    nb_load_store_queue             ,
                         uint32_t  * size_store_queue                ,
 …
                         uint32_t ** link_load_store_unit_with_thread,
                         uint32_t    nb_inst_insert                  ,
+                        uint32_t    nb_inst_retire                  );
+                        uint32_t    nb_inst_retire                  ,
+                        bool        is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
+#if DEBUG_Load_Store_pointer_unit == true
+    log_printf(INFO,Load_Store_pointer_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Load_Store_pointer_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Load_Store_pointer_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Load_Store_pointer_unit,FUNCTION,"Method - transition");
 …
             sensitive << (*(in_RETIRE_LOAD_QUEUE_PTR_WRITE  [i]));
             sensitive << (*(in_RETIRE_VAL                   [i]))
+                      << (*(in_RETIRE_TYPE                  [i]))
+                      << (*(in_RETIRE_OPERATION             [i]))
+//                    << (*(in_RETIRE_TYPE                  [i]))
+//                    << (*(in_RETIRE_OPERATION             [i]))
+                      << (*(in_RETIRE_USE_STORE_QUEUE       [i]))
+                      << (*(in_RETIRE_USE_LOAD_QUEUE        [i]))
                       << (*(in_RETIRE_STORE_QUEUE_PTR_WRITE [i]));;
+          }
 …
             if (_param->_have_port_context_id)
             (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_CONTEXT_ID            [i]));
+            (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_TYPE                  [i]));
+            (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_OPERATION             [i]));
+//          (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_TYPE                  [i]));
+//          (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_OPERATION             [i]));
+            (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_USE_STORE_QUEUE       [i]));
+            (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_USE_LOAD_QUEUE        [i]));
             if (_param->_have_port_load_queue_ptr)
             (*(out_RETIRE_ACK                   [i])) (*( in_RETIRE_LOAD_QUEUE_PTR_WRITE  [i]));
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Load_Store_pointer_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_allocation.cpp

-              r81
+              r88
       ALLOC1_SIGNAL_IN ( in_RETIRE_FRONT_END_ID         ,"front_end_id"         ,Tcontext_t  ,_param->_size_front_end_id   );
       ALLOC1_SIGNAL_IN ( in_RETIRE_CONTEXT_ID           ,"context_id"           ,Tcontext_t  ,_param->_size_context_id     );
+      ALLOC1_SIGNAL_IN ( in_RETIRE_TYPE                 ,"type"                 ,Ttype_t     ,_param->_size_type           );
+      ALLOC1_SIGNAL_IN ( in_RETIRE_OPERATION            ,"operation"            ,Toperation_t,_param->_size_operation      );
+//       ALLOC1_SIGNAL_IN ( in_RETIRE_TYPE                 ,"type"                 ,Ttype_t     ,_param->_size_type           );
+//       ALLOC1_SIGNAL_IN ( in_RETIRE_OPERATION            ,"operation"            ,Toperation_t,_param->_size_operation      );
+      ALLOC1_SIGNAL_IN ( in_RETIRE_USE_STORE_QUEUE      ,"use_store_queue"      ,Tcontrol_t  ,_param->_size_operation      );
+      ALLOC1_SIGNAL_IN ( in_RETIRE_USE_LOAD_QUEUE       ,"use_load_queue"       ,Tcontrol_t  ,_param->_size_operation      );
       ALLOC1_SIGNAL_IN ( in_RETIRE_STORE_QUEUE_PTR_WRITE,"store_queue_ptr_write",Tlsq_ptr_t  ,_param->_size_store_queue_ptr);
       ALLOC1_SIGNAL_IN ( in_RETIRE_LOAD_QUEUE_PTR_WRITE ,"load_queue_ptr_write" ,Tlsq_ptr_t  ,_param->_size_load_queue_ptr );
+    }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     reg_STORE_QUEUE_PTR_WRITE     = new Tlsq_ptr_t      [_param->_nb_load_store_queue];
     reg_STORE_QUEUE_USE           = new bool *          [_param->_nb_load_store_queue];
 …
     internal_RETIRE_LSQ           = new uint32_t        [_param->_nb_inst_retire];
     internal_RETIRE_PTR           = new Tlsq_ptr_t      [_param->_nb_inst_retire];
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         if (_param->_have_port_context_id)
         delete []  in_RETIRE_CONTEXT_ID           ;
+        delete []  in_RETIRE_TYPE                 ;
+        delete []  in_RETIRE_OPERATION            ;
+//      delete []  in_RETIRE_TYPE                 ;
+//      delete []  in_RETIRE_OPERATION            ;
+        delete []  in_RETIRE_USE_STORE_QUEUE      ;
+        delete []  in_RETIRE_USE_LOAD_QUEUE       ;
         delete []  in_RETIRE_STORE_QUEUE_PTR_WRITE;
         if (_param->_have_port_load_queue_ptr)
         delete []  in_RETIRE_LOAD_QUEUE_PTR_WRITE ;
+        delete [] reg_STORE_QUEUE_PTR_WRITE    ;
+        delete [] reg_STORE_QUEUE_USE          ;
+        delete [] reg_STORE_QUEUE_NB_USE       ;
+        delete [] reg_LOAD_QUEUE_PTR_WRITE     ;
+        delete [] reg_LOAD_QUEUE_USE           ;
+        delete [] internal_INSERT_ACK          ;
+        delete [] internal_INSERT_OPERATION_USE;
+        delete [] internal_INSERT_LSQ          ;
+        delete [] internal_INSERT_PTR          ;
+        delete [] internal_RETIRE_ACK          ;
+        delete [] internal_RETIRE_OPERATION_USE;
+        delete [] internal_RETIRE_LSQ          ;
+        delete [] internal_RETIRE_PTR          ;
+      }
-    delete [] reg_STORE_QUEUE_PTR_WRITE    ;
-    delete [] reg_STORE_QUEUE_USE          ;
-    delete [] reg_STORE_QUEUE_NB_USE       ;
-    delete [] reg_LOAD_QUEUE_PTR_WRITE     ;
-    delete [] reg_LOAD_QUEUE_USE           ;
-    delete [] internal_INSERT_ACK          ;
-    delete [] internal_INSERT_OPERATION_USE;
-    delete [] internal_INSERT_LSQ          ;
-    delete [] internal_INSERT_PTR          ;
-    delete [] internal_RETIRE_ACK          ;
-    delete [] internal_RETIRE_OPERATION_USE;
-    delete [] internal_RETIRE_LSQ          ;
-    delete [] internal_RETIRE_PTR          ;
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Load_Store_pointer_unit_genMealy_retire.cpp

-              r81
+              r88
+      {
         Tcontrol_t ack = false;
+        if ( (PORT_READ(in_RETIRE_VAL  [i]) == true       ) and
+             (PORT_READ(in_RETIRE_TYPE [i]) == TYPE_MEMORY))
+        Tcontrol_t use_sq  = PORT_READ(in_RETIRE_USE_STORE_QUEUE [i]);
+        Tcontrol_t use_lq  = PORT_READ(in_RETIRE_USE_LOAD_QUEUE  [i]);
+        if ( (PORT_READ(in_RETIRE_VAL  [i]) == true) and (use_sq or use_lq))
+//           (PORT_READ(in_RETIRE_TYPE [i]) == TYPE_MEMORY))
+          {
             Tcontext_t front_end_id = (_param->_have_port_front_end_id)?PORT_READ(in_RETIRE_FRONT_END_ID [i]):0;
 …
                 // operation became of decod_stage. Also operation is != store_head_ok and store_head_ko
+                if (is_operation_memory_store(PORT_READ(in_RETIRE_OPERATION [i])))
+//              if (is_operation_memory_store(PORT_READ(in_RETIRE_OPERATION [i])))
+                if (use_sq)
+                  {
                     internal_RETIRE_OPERATION_USE [i] = OPERATION_USE_STORE_QUEUE;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Parameters.cpp

-              r81
+              r88
   Parameters::Parameters (uint32_t    nb_front_end                    ,
                           uint32_t  * nb_context                      ,
+//                           uint32_t    size_front_end_id               ,
+//                           uint32_t    size_context_id                 ,
                           uint32_t    nb_load_store_queue             ,
                           uint32_t  * size_store_queue                ,
 …
                           uint32_t ** link_load_store_unit_with_thread,
                           uint32_t    nb_inst_insert                  ,
+                          uint32_t    nb_inst_retire                  )
+                          uint32_t    nb_inst_retire                  ,
+                          bool        is_toplevel
+                          )
+  {
     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
 …
     _nb_inst_retire                   = nb_inst_retire                  ;
+    uint32_t max_nb_context       = max<uint32_t>(nb_context,       nb_front_end);
+    uint32_t max_size_store_queue = max<uint32_t>(size_store_queue, nb_load_store_queue);
+    uint32_t max_size_load_queue  = max<uint32_t>(size_load_queue,  nb_load_store_queue);
+    test();
+    _size_front_end_id                = log2(nb_front_end        );
+    _size_context_id                  = log2(max_nb_context      );
+    _size_store_queue_ptr             = log2(max_size_store_queue);
+    _size_load_queue_ptr              = log2(max_size_load_queue );
+    _have_port_front_end_id           = (_size_front_end_id   > 0);
+    _have_port_context_id             = (_size_context_id     > 0);
+    _have_port_load_queue_ptr         = (_size_load_queue_ptr > 0);
+    if (is_toplevel)
+      {
+        _size_front_end_id                = log2(_nb_front_end);
+        _size_context_id                  = log2(max<uint32_t>(_nb_context,_nb_front_end));
+        _size_store_queue_ptr             = log2(max<uint32_t>(size_store_queue, nb_load_store_queue));
+        _size_load_queue_ptr              = log2(max<uint32_t>(size_load_queue,  nb_load_store_queue));
+        _have_port_front_end_id           = (_size_front_end_id   > 0);
+        _have_port_context_id             = (_size_context_id     > 0);
+        _have_port_load_queue_ptr         = (_size_load_queue_ptr > 0);
+    test();
+        copy();
+      }
     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
   };
 …
 #undef  FUNCTION
 #define FUNCTION "Load_Store_pointer_unit::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");
+    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Load_Store_pointer_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit/src/Parameters_msg_error.cpp

-              r82
+              r88
         test.error(toString(_("The load store unit [%d] is not linked with a thread.\n"),i));
+    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
     return test;
-    log_printf(FUNC,Load_Store_pointer_unit,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Dependency_checking_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_general_register,
          _nb_special_register,
+         _nb_inst_insert     );
+         _nb_inst_insert     ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Dependency_checking_unit * _Dependency_checking_unit = new Dependency_checking_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/include/Parameters.h

-              r82
+              r88
   public : uint32_t   _nb_inst_insert        ;
   public : uint32_t   _size_front_end_id     ;
   public : uint32_t   _size_context_id       ;
   public : uint32_t   _size_general_register ;
   public : uint32_t   _size_special_register ;
   public : uint32_t   _have_port_context_id  ;
   public : uint32_t   _have_port_front_end_id;
+//public : uint32_t   _size_front_end_id     ;
+//public : uint32_t   _size_context_id       ;
+//public : uint32_t   _size_general_register ;
+//public : uint32_t   _size_special_register ;
+//public : uint32_t   _have_port_context_id  ;
+//public : uint32_t   _have_port_front_end_id;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t nb_general_register   ,
                         uint32_t nb_special_register   ,
+                        uint32_t nb_inst_insert        );
+                        uint32_t nb_inst_insert        ,
+                        bool     is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
   public :        Parameters_test msg_error  (void);
+  public :        void            copy       (void);
   public :        std::string     print      (uint32_t depth);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");
+#if DEBUG_Dependency_checking_unit == true
+    log_printf(INFO,Dependency_checking_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Dependency_checking_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Dependency_checking_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 # if defined(STATISTICS) or defined(VHDL_TESTBENCH)
 …
         SC_METHOD (genMealy);
         dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg();
+//      sensitive << (*(in_CLOCK)).neg(); // don't need internal register
         for (uint32_t i=0;i<_param->_nb_inst_insert; i++)
+          {
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Dependency_checking_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit_allocation.cpp

-              r81
+              r88
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit_deallocation.cpp

r81	r88
24	24	log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");
25	25
26		if (~~_usage & USE_SYSTEMC~~)
	26	if (usage_is_set(_usage,USE_SYSTEMC))
27	27	{
28	28	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Dependency_checking_unit_genMealy.cpp

-              r81
+              r88
   void Dependency_checking_unit::genMealy (void)
+  {
+    log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");
+    log_begin(Dependency_checking_unit,FUNCTION);
+    log_function(Dependency_checking_unit,FUNCTION,_name.c_str());
 //     Tcontrol_t         val                [_param->_nb_inst_insert];
 …
         num_reg_re_phy_new [i] = PORT_READ(in_RENAME_IN_NUM_REG_RE_PHY_NEW [i]);
+        log_printf(TRACE,Dependency_checking_unit,FUNCTION,"  * (before) [%d] %.2d %.2d, %.1d %.2d %.5d, %.1d %.2d %.5d, %.1d %.2d %.5d, %.1d %.2d %.5d -> %.5d, %.1d %.2d %.5d -> %.5d",
+                   i,
+                   front_end_id       [i],
+                   context_id         [i],
+                   read_ra            [i],
+                   num_reg_ra_log     [i],
+                   num_reg_ra_phy     [i],
+                   read_rb            [i],
+                   num_reg_rb_log     [i],
+                   num_reg_rb_phy     [i],
+                   read_rc            [i],
+                   num_reg_rc_log     [i],
+                   num_reg_rc_phy     [i],
+                   write_rd           [i],
+                   num_reg_rd_log     [i],
+                   num_reg_rd_phy_old [i],
+                   num_reg_rd_phy_new [i],
+                   write_re           [i],
+                   num_reg_re_log     [i],
+                   num_reg_re_phy_old [i],
+                   num_reg_re_phy_new [i]);
         // ================================================================
         // =====[ Write after Write ]======================================
 …
                 (context_id     [j] == context_id     [i]) )
+              {
+                log_printf(TRACE,Dependency_checking_unit,FUNCTION,"    * RD :  WAW dependency with inst[%d].RD",j);
                 num_reg_rd_phy_old [i] = num_reg_rd_phy_new [j];
                 break; // find the most recently dependency
 …
                 (context_id     [j] == context_id     [i]) )
+              {
+                log_printf(TRACE,Dependency_checking_unit,FUNCTION,"    * RE : WAW dependency with inst[%d].RE",j);
                 num_reg_re_phy_old [i] = num_reg_re_phy_new [j];
                 break; // find the most recently dependency
 …
                 (context_id     [j] == context_id     [i]) )
+              {
+                log_printf(TRACE,Dependency_checking_unit,FUNCTION,"    * RA :  RAW dependency with inst[%d].RD",j);
                 num_reg_ra_phy [i] = num_reg_rd_phy_new [j];
                 break; // find the most recently dependency
 …
                 (context_id     [j] == context_id     [i]) )
+              {
+                log_printf(TRACE,Dependency_checking_unit,FUNCTION,"    * RB :  RAW dependency with inst[%d].RD",j);
                 num_reg_rb_phy [i] = num_reg_rd_phy_new [j];
                 break; // find the most recently dependency
 …
                 (context_id     [j] == context_id     [i]) )
+              {
+                log_printf(TRACE,Dependency_checking_unit,FUNCTION,"    * RC :  RAW dependency with inst[%d].RE",j);
                 num_reg_rc_phy [i] = num_reg_re_phy_new [j];
                 break; // find the most recently dependency
+              }
+        log_printf(TRACE,Dependency_checking_unit,FUNCTION,"  * (after ) [%d] %.2d %.2d, %.1d %.2d %.5d, %.1d %.2d %.5d, %.1d %.2d %.5d, %.1d %.2d %.5d -> %.5d, %.1d %.2d %.5d -> %.5d",
+                   i,
+                   front_end_id       [i],
+                   context_id         [i],
+                   read_ra            [i],
+                   num_reg_ra_log     [i],
+                   num_reg_ra_phy     [i],
+                   read_rb            [i],
+                   num_reg_rb_log     [i],
+                   num_reg_rb_phy     [i],
+                   read_rc            [i],
+                   num_reg_rc_log     [i],
+                   num_reg_rc_phy     [i],
+                   write_rd           [i],
+                   num_reg_rd_log     [i],
+                   num_reg_rd_phy_old [i],
+                   num_reg_rd_phy_new [i],
+                   write_re           [i],
+                   num_reg_re_log     [i],
+                   num_reg_re_phy_old [i],
+                   num_reg_re_phy_new [i]);
         // =====[ Output ]=================================================
 …
+      }
     log_printf(FUNC,Dependency_checking_unit,FUNCTION,"End");
+    log_end(Dependency_checking_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t nb_general_register   ,
                           uint32_t nb_special_register   ,
+                          uint32_t nb_inst_insert        )
+                          uint32_t nb_inst_insert        ,
+                          bool     is_toplevel           )
+  {
     log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");
 …
     _nb_inst_insert      = nb_inst_insert     ;
+    _size_front_end_id      = log2(nb_front_end       );
+    _size_context_id        = log2(max_nb_context     );
+    _size_general_register  = log2(nb_general_register);
+    _size_special_register  = log2(nb_special_register);
+    _have_port_front_end_id = _size_front_end_id>0;
+    _have_port_context_id   = _size_context_id  >0;
+    test();
+    test();
+    if (is_toplevel)
+      {
+        _size_front_end_id      = log2(nb_front_end       );
+        _size_context_id        = log2(max_nb_context     );
+        _size_general_register  = log2(nb_general_register);
+        _size_special_register  = log2(nb_special_register);
+        _have_port_front_end_id = _size_front_end_id>0;
+        _have_port_context_id   = _size_context_id  >0;
+        copy();
+      }
     log_printf(FUNC,Dependency_checking_unit,FUNCTION,"End");
   };
 …
 #undef  FUNCTION
 #define FUNCTION "Dependency_checking_unit::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");
+    log_printf(FUNC,Dependency_checking_unit,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Dependency_checking_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Dependency_checking_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Free_List_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_pop             ,
          _nb_push            ,
+         _priority           );
+         _priority           ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Free_List_unit * _Free_List_unit = new Free_List_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/include/Parameters.h

-              r82
+              r88
   public : Tpriority_t _priority             ;
   public : uint32_t    _size_general_register;
   public : uint32_t    _size_special_register;
+//public : uint32_t    _size_general_register;
+//public : uint32_t    _size_special_register;
   public : uint32_t    _nb_bank_by_pop       ;
 …
                         uint32_t    nb_pop             ,
                         uint32_t    nb_push            ,
+                        Tpriority_t priority           );
+                        Tpriority_t priority           ,
+                        bool        is_toplevel=false);
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
   public :        Parameters_test msg_error  (void);
+  public :        void            copy       (void);
   public :        std::string     print      (uint32_t depth);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
+#if DEBUG_Free_List_unit == true
+    log_printf(INFO,Free_List_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Free_List_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Free_List_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Free_List_unit,FUNCTION,"Method - transition");
 …
         SC_METHOD (genMealy_pop);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
         for (uint32_t i=0; i<_param->_nb_pop; i++)
           sensitive << (*(in_POP_GPR_VAL[i]))
 …
         SC_METHOD (genMealy_push_gpr);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
         for (uint32_t i=0; i<_param->_nb_push; i++)
           sensitive << (*(in_PUSH_GPR_VAL    [i]))
 …
         SC_METHOD (genMealy_push_spr);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
         for (uint32_t i=0; i<_param->_nb_push; i++)
           sensitive << (*(in_PUSH_SPR_VAL    [i]))
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Free_List_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_allocation.cpp

-              r81
+              r88
+     }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     if (usage_is_set(_usage,USE_SYSTEMC))
+       {
      _gpr_list = new std::list<uint32_t> [_param->_nb_bank];
      _spr_list = new std::list<uint32_t> [_param->_nb_bank];
 …
      internal_PUSH_GPR_BANK = new uint32_t   [_param->_nb_push];
      internal_PUSH_SPR_BANK = new uint32_t   [_param->_nb_push];
+       }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         delete [] out_PUSH_SPR_ACK    ;
         delete []  in_PUSH_SPR_NUM_REG;
+        delete [] _gpr_list;
+        delete [] _spr_list;
+        delete [] internal_POP_ACK     ;
+        delete [] internal_POP_GPR_BANK;
+        delete [] internal_POP_SPR_BANK;
+        delete [] internal_PUSH_GPR_ACK ;
+        delete [] internal_PUSH_SPR_ACK ;
+        delete [] internal_PUSH_GPR_BANK;
+        delete [] internal_PUSH_SPR_BANK;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-     delete [] _gpr_list;
-     delete [] _spr_list;
-     delete [] internal_POP_ACK     ;
-     delete [] internal_POP_GPR_BANK;
-     delete [] internal_POP_SPR_BANK;
-     delete [] internal_PUSH_GPR_ACK ;
-     delete [] internal_PUSH_SPR_ACK ;
-     delete [] internal_PUSH_GPR_BANK;
-     delete [] internal_PUSH_SPR_BANK;
      delete _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_genMealy_pop.cpp

-              r81
+              r88
   void Free_List_unit::genMealy_pop (void)
+  {
+    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
+    log_begin(Free_List_unit,FUNCTION);
+    log_function(Free_List_unit,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_pop; i++)
 …
     log_printf(FUNC,Free_List_unit,FUNCTION,"End");
+    log_end(Free_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_genMealy_push_gpr.cpp

-              r81
+              r88
   void Free_List_unit::genMealy_push_gpr (void)
+  {
+    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
+    log_begin(Free_List_unit,FUNCTION);
+    log_function(Free_List_unit,FUNCTION,_name.c_str());
     bool bank_use [_param->_nb_bank];
 …
+      }
     log_printf(FUNC,Free_List_unit,FUNCTION,"End");
+    log_end(Free_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_genMealy_push_spr.cpp

-              r81
+              r88
   void Free_List_unit::genMealy_push_spr (void)
+  {
+    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
+    log_begin(Free_List_unit,FUNCTION);
+    log_function(Free_List_unit,FUNCTION,_name.c_str());
     bool bank_use [_param->_nb_bank];
 …
+      }
     log_printf(FUNC,Free_List_unit,FUNCTION,"End");
+    log_end(Free_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Free_List_unit_transition.cpp

-              r81
+              r88
   void Free_List_unit::transition (void)
+  {
+    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
+    log_begin(Free_List_unit,FUNCTION);
+    log_function(Free_List_unit,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
         // =====[ POP ]======================================
         // ==================================================
-//      log_printf(TRACE,Free_List_unit,FUNCTION,"Test transaction POP");
         for (uint32_t i=0; i<_param->_nb_pop; i++)
           if (PORT_READ(in_POP_VAL[i]) and internal_POP_ACK [i])
+            {
+              log_printf(TRACE,Free_List_unit,FUNCTION,"  * POP [%d]",i);
               if (PORT_READ(in_POP_GPR_VAL [i]))
                 _gpr_list [internal_POP_GPR_BANK[i]].pop_front();
 …
         // =====[ PUSH_GPR ]=================================
         // ==================================================
-//      log_printf(TRACE,Free_List_unit,FUNCTION,"Test transaction PUSH_GPR");
         for (uint32_t i=0; i<_param->_nb_push; i++)
           if (PORT_READ(in_PUSH_GPR_VAL[i]) and internal_PUSH_GPR_ACK [i])
+            _gpr_list [internal_PUSH_GPR_BANK[i]].push_back(//_param->_mask_gpr &
                                                             PORT_READ(in_PUSH_GPR_NUM_REG [i]));
+            {
+              log_printf(TRACE,Free_List_unit,FUNCTION,"  * PUSH_GPR[%d]",i);
+              _gpr_list [internal_PUSH_GPR_BANK[i]].push_back(//_param->_mask_gpr &
+                                                              PORT_READ(in_PUSH_GPR_NUM_REG [i]));
+            }
         // ==================================================
         // =====[ PUSH_SPR ]=================================
         // ==================================================
-//      log_printf(TRACE,Free_List_unit,FUNCTION,"Test transaction PUSH_SPR");
         for (uint32_t i=0; i<_param->_nb_push; i++)
           if (PORT_READ(in_PUSH_SPR_VAL[i]) and internal_PUSH_SPR_ACK [i])
+            _spr_list [internal_PUSH_SPR_BANK[i]].push_back(//_param->_mask_spr &
+                                                            PORT_READ(in_PUSH_SPR_NUM_REG [i]));
+            {
+              log_printf(TRACE,Free_List_unit,FUNCTION,"  * PUSH_SPR[%d]",i);
+              _spr_list [internal_PUSH_SPR_BANK[i]].push_back(//_param->_mask_spr &
+                                                              PORT_READ(in_PUSH_SPR_NUM_REG [i]));
+            }
         if (_param->_priority == PRIORITY_ROUND_ROBIN)
           internal_BANK_PRIORITY = (internal_BANK_PRIORITY+1)%_param->_nb_bank_by_pop;
+#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Free_List_unit == true)
+        log_printf(TRACE,Free_List_unit,FUNCTION,"  * Dump Free List");
+        for (uint32_t i=0; i<_param->_nb_bank; ++i)
+          {
+            uint32_t j=0;
+            for (std::list<Tgeneral_address_t>::iterator it=_gpr_list->begin();
+                 it!=_gpr_list->end();
+                 ++it)
+              {
+                log_printf(TRACE,Free_List_unit,FUNCTION,"    * GPR_LIST[%.5d][%.5d] : %.5d",i,j,*it);
+                ++j;
+              }
+          }
+        for (uint32_t i=0; i<_param->_nb_bank; ++i)
+          {
+            uint32_t j=0;
+            for (std::list<Tspecial_address_t>::iterator it=_spr_list->begin();
+                 it!=_spr_list->end();
+                 ++it)
+              {
+                log_printf(TRACE,Free_List_unit,FUNCTION,"    * SPR_LIST[%.5d][%.5d] : %.5d",i,j,*it);
+                ++j;
+              }
+          }
+#endif
+      }
 …
 #endif
     log_printf(FUNC,Free_List_unit,FUNCTION,"End");
+    log_end(Free_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t    nb_pop             ,
                           uint32_t    nb_push            ,
+                          Tpriority_t priority           )
+                          Tpriority_t priority           ,
+                          bool        is_toplevel        )
+  {
     log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
 …
     test();
     _size_general_register = log2(nb_general_register);
     _size_special_register = log2(nb_special_register);
+    uint32_t size_general_register = log2(nb_general_register);
+    uint32_t size_special_register = log2(nb_special_register);
     _nb_bank_by_pop        = _nb_bank / _nb_pop;
 …
     _bank_gpr_nb_slot      = gpr_nb_slot/nb_bank;
     _bank_gpr_size_slot    = _size_general_register-log2(nb_bank);
+    _bank_gpr_size_slot    = size_general_register-log2(nb_bank);
     _mask_gpr              = gen_mask<Tgeneral_address_t> (_bank_gpr_size_slot);
 …
     _bank_spr_nb_slot      = spr_nb_slot/nb_bank;
     _bank_spr_size_slot    = _size_special_register-log2(nb_bank);
+    _bank_spr_size_slot    = size_special_register-log2(nb_bank);
     _mask_spr              = gen_mask<Tspecial_address_t> (_bank_spr_size_slot);
+    if (is_toplevel)
+      {
+        _size_general_register = size_general_register;
+        _size_special_register = size_special_register;
+        copy();
+      }
     log_printf(FUNC,Free_List_unit,FUNCTION,"End");
 …
 #undef  FUNCTION
 #define FUNCTION "Free_List_unit::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");
+    log_printf(FUNC,Free_List_unit,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Free_List_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Free_List_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit/src/Parameters_msg_error.cpp

-              r82
+              r88
     if (_nb_general_register <= _nb_thread*_nb_general_register_logic)
       test.error(_("The number of physical general register is insufficient.\n"));
+      test.error(toString(_("The number of physical general register is insufficient. (Minimum : %d)\n"),_nb_thread*_nb_general_register_logic+1));
     if (_nb_special_register <= _nb_thread*_nb_special_register_logic)
       test.error(_("The number of physical special register is insufficient.\n"));
+      test.error(toString(_("The number of physical special register is insufficient. (Minimum : %d)\n"),_nb_thread*_nb_special_register_logic+1));
     if (not is_multiple (_nb_bank, _nb_pop))
       test.error(_("Number of pop must be a multiple of number of bank.\n"));
     if (not is_power2 (_nb_bank))
       test.error(_("Number of bank must be a power of 2.\n"));
+    if (_nb_general_register < _nb_bank)
+      test.error(_("The number of physical general register must be >= nb_bank.\n"));
+    if (_nb_special_register < _nb_bank)
+      test.error(_("The number of physical special register must be >= nb_bank.\n"));
     if ((_priority != PRIORITY_STATIC) and

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Register_Address_Translation_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_special_register ,
          _nb_inst_insert      ,
+         _nb_inst_retire      );
+         _nb_inst_retire      ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Register_Address_Translation_unit * _Register_Address_Translation_unit = new Register_Address_Translation_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RD_PHY_OLD," in_RETIRE_NUM_REG_RD_PHY_OLD",Tgeneral_address_t,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RE_PHY_OLD," in_RETIRE_NUM_REG_RE_PHY_OLD",Tspecial_address_t,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL(out_RETIRE_RESTORE_RD_PHY_OLD,"out_RETIRE_RESTORE_RD_PHY_OLD",Tcontrol_t        ,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL(out_RETIRE_RESTORE_RE_PHY_OLD,"out_RETIRE_RESTORE_RE_PHY_OLD",Tcontrol_t        ,_param->_nb_inst_retire);
   /********************************************************
 …
   INSTANCE1_SC_SIGNAL(_Register_Address_Translation_unit, in_RETIRE_NUM_REG_RD_PHY_OLD,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Register_Address_Translation_unit, in_RETIRE_NUM_REG_RE_PHY_OLD,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_Address_Translation_unit,out_RETIRE_RESTORE_RD_PHY_OLD,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_Address_Translation_unit,out_RETIRE_RESTORE_RE_PHY_OLD,_param->_nb_inst_retire);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
+            }
+          uint32_t retire_max = _param->_nb_inst_retire;
           for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+            {
+              Tcontrol_t val = (rand()%100)<percent_transaction_retire;
+              // in order ...........
+              Tcontrol_t val = (i<retire_max) and ((rand()%100)<percent_transaction_retire);
+              if (not val)
+                retire_max = i;
               Tcontext_t front_end_id = rand() % _param->_nb_front_end;
 …
+                }
+            }
+          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+            {
+              TEST(Tcontrol_t,out_RETIRE_RESTORE_RD_PHY_OLD[i]->read(), 0);
+              TEST(Tcontrol_t,out_RETIRE_RESTORE_RE_PHY_OLD[i]->read(), 0);
+            }
           for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+            {
 …
       SC_START(1);
+      // EVENT !!!!!!!!
       nb_request = 32;
       while (nb_request > 1)
 …
+            }
+          uint32_t retire_max = _param->_nb_inst_retire;
           for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+            {
+              Tcontrol_t val = (rand()%100)<percent_transaction_retire;
+              // in order ...........
+              Tcontrol_t val = (i<retire_max) and ((rand()%100)<percent_transaction_retire);
+              if (not val)
+                retire_max = i;
               in_RETIRE_VAL                [i]->write(val);
               in_RETIRE_FRONT_END_ID       [i]->write(retire_front_end_id [i]);
 …
+            }
           SC_START(1);
+          SC_START(0);
 …
           for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+            {
+              LABEL("RETIRE[%d]",i);
               Tcontext_t front_end_id = in_RETIRE_FRONT_END_ID [i]->read();
               Tcontext_t context_id   = in_RETIRE_CONTEXT_ID   [i]->read();
+              LABEL("  * front_end_id : %d",front_end_id);
+              LABEL("  * context_id   : %d",context_id  );
               if (in_RETIRE_VAL [i]->read() and out_RETIRE_ACK [i]->read())
+                {
                   if (in_RETIRE_WRITE_RD [i]->read() == 1)
+                    {
+//                       LABEL("  * transaction and write rd");
+//                       LABEL("    * rd_log       : %d",in_RETIRE_NUM_REG_RD_LOG[i]->read());
+//                       LABEL("    * rat_gpr_updt : %d",rat_gpr_updt [front_end_id][context_id][in_RETIRE_NUM_REG_RD_LOG[i]->read()]);
+                      TEST(Tcontrol_t,out_RETIRE_RESTORE_RD_PHY_OLD[i]->read(), (rat_gpr_updt [front_end_id][context_id][in_RETIRE_NUM_REG_RD_LOG[i]->read()] == false));
                       if (rat_gpr_updt [front_end_id][context_id][in_RETIRE_NUM_REG_RD_LOG[i]->read()] == false)
                         rat_gpr[front_end_id][context_id][in_RETIRE_NUM_REG_RD_LOG[i]->read()] = in_RETIRE_NUM_REG_RD_PHY_OLD[i]->read();
 …
                   if (in_RETIRE_WRITE_RE [i]->read() == 1)
+                    {
+                      TEST(Tcontrol_t,out_RETIRE_RESTORE_RE_PHY_OLD[i]->read(), (rat_spr_updt [front_end_id][context_id][in_RETIRE_NUM_REG_RE_LOG[i]->read()] == false));
                       if (rat_spr_updt [front_end_id][context_id][in_RETIRE_NUM_REG_RE_LOG[i]->read()] == false)
                         rat_spr[front_end_id][context_id][in_RETIRE_NUM_REG_RE_LOG[i]->read()] = in_RETIRE_NUM_REG_RE_PHY_OLD[i]->read();
 …
+                }
+            }
+          SC_START(1);
           for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+            {
 …
                   TEST(Tspecial_address_t,out_RENAME_NUM_REG_RE_PHY_OLD[i]->read(), rat_spr[front_end_id][context_id][in_RENAME_NUM_REG_RE_LOG[i]->read()]);
+                }
+            }
+            }
+        }
+    }
 …
   delete []  in_RETIRE_NUM_REG_RD_PHY_OLD;
   delete []  in_RETIRE_NUM_REG_RE_PHY_OLD;
+  delete [] out_RETIRE_RESTORE_RD_PHY_OLD;
+  delete [] out_RETIRE_RESTORE_RE_PHY_OLD;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/include/Parameters.h

-              r82
+              r88
   public : uint32_t   _nb_inst_retire        ;
   public : uint32_t   _size_front_end_id     ;
   public : uint32_t   _size_context_id       ;
   public : uint32_t   _size_general_register ;
   public : uint32_t   _size_special_register ;
   public : uint32_t   _have_port_context_id  ;
   public : uint32_t   _have_port_front_end_id;
+//public : uint32_t   _size_front_end_id     ;
+//public : uint32_t   _size_context_id       ;
+//public : uint32_t   _size_general_register ;
+//public : uint32_t   _size_special_register ;
+//
+//public : uint32_t   _have_port_context_id  ;
+//public : uint32_t   _have_port_front_end_id;
     //-----[ methods ]-----------------------------------------------------------
 …
                         uint32_t   nb_special_register,
                         uint32_t   nb_inst_insert     ,
+                        uint32_t   nb_inst_retire
+                        uint32_t   nb_inst_retire     ,
+                        bool       is_toplevel=false
                         );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/include/Register_Address_Translation_unit.h

-              r82
+              r88
   public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RD_PHY_OLD;//[nb_inst_retire]
   public    : SC_IN (Tspecial_address_t)   **  in_RETIRE_NUM_REG_RE_PHY_OLD;//[nb_inst_retire]
+  public    : SC_OUT(Tcontrol_t        )   ** out_RETIRE_RESTORE_RD_PHY_OLD;//[nb_inst_retire]
+  public    : SC_OUT(Tcontrol_t        )   ** out_RETIRE_RESTORE_RE_PHY_OLD;//[nb_inst_retire]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  private   : Tgeneral_address_t          *** rat_gpr;                      //[nb_front_end][nb_context][nb_general_register_logic]
+  private   : bool                        *** rat_gpr_update_table;         //[nb_front_end][nb_context][nb_general_register_logic]
+  private   : Tspecial_address_t          *** rat_spr;                      //[nb_front_end][nb_context][nb_special_register_logic]
+  private   : bool                        *** rat_spr_update_table;         //[nb_front_end][nb_context][nb_special_register_logic]
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   private   : Tcontrol_t                    * internal_RETIRE_ACK;          //[nb_inst_retire]
+  private   : Tgeneral_address_t          *** rat_gpr;                      //[nb_front_end][nb_context][nb_general_register_logic]
+  private   : bool                        *** rat_gpr_update_table;         //[nb_front_end][nb_context][nb_general_register_logic]
+  private   : Tspecial_address_t          *** rat_spr;                      //[nb_front_end][nb_context][nb_special_register_logic]
+  private   : bool                        *** rat_spr_update_table;         //[nb_front_end][nb_context][nb_special_register_logic]
+  private   : bool                        *** internal_rat_gpr_update_table;         //[nb_front_end][nb_context][nb_general_register_logic]
+  private   : bool                        *** internal_rat_spr_update_table;         //[nb_front_end][nb_context][nb_special_register_logic]
 #endif
 …
 #ifdef SYSTEMC
   public  : void        transition                (void);
+  public  : void        genMoore                  (void);
+  public  : void        genMealy_rename           (void);
+  public  : void        genMealy_retire           (void);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_special_register,
                           uint32_t   nb_inst_insert     ,
+                          uint32_t   nb_inst_retire     )
+                          uint32_t   nb_inst_retire     ,
+                          bool       is_toplevel)
+  {
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
 …
     _nb_inst_retire         = nb_inst_retire     ;
+    _size_front_end_id      = log2(nb_front_end       );
+    _size_context_id        = log2(max<uint32_t>(nb_context, nb_front_end));
+    _size_general_register  = log2(nb_general_register);
+    _size_special_register  = log2(nb_special_register);
+    test();
+    if (is_toplevel)
+      {
+        _size_front_end_id      = log2(nb_front_end       );
+        _size_context_id        = log2(max<uint32_t>(nb_context, nb_front_end));
+        _size_general_register  = log2(nb_general_register);
+        _size_special_register  = log2(nb_special_register);
+    _have_port_front_end_id = _size_front_end_id>0;
+    _have_port_context_id   = _size_context_id  >0;
+    test();
+        _have_port_front_end_id = _size_front_end_id>0;
+        _have_port_context_id   = _size_context_id  >0;
+        copy();
+      }
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"End");
 …
 #undef  FUNCTION
 #define FUNCTION "Register_Address_Translation_unit::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
+    log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Register_Address_Translation_unit::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
+#if DEBUG_Register_Address_Translation_unit == true
+    log_printf(INFO,Register_Address_Translation_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         // Constant : accepted already transaction
 …
 # endif
         log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Method - genMoore");
+        log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Method - genMealy_rename");
         SC_METHOD (genMoore);
+        SC_METHOD (genMealy_rename);
         dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
+        for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+          {
+            if (_param->_have_port_front_end_id)
+            sensitive << (*(in_RENAME_FRONT_END_ID   [i]));
+            if (_param->_have_port_context_id  )
+            sensitive << (*(in_RENAME_CONTEXT_ID     [i]));
+            sensitive << (*(in_RENAME_NUM_REG_RA_LOG [i]))
+                      << (*(in_RENAME_NUM_REG_RB_LOG [i]))
+                      << (*(in_RENAME_NUM_REG_RC_LOG [i]))
+                      << (*(in_RENAME_NUM_REG_RD_LOG [i]))
+                      << (*(in_RENAME_NUM_REG_RE_LOG [i]));
+      }
+# ifdef SYSTEMCASS_SPECIFIC
+        // List dependency information
+# endif
+        log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Method - genMealy_retire");
+        SC_METHOD (genMealy_retire);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
+        for (uint32_t i=0; i<_param->_nb_inst_retire; ++i)
+          {
+            if (param->_have_port_front_end_id)
+            sensitive << (*(in_RETIRE_FRONT_END_ID   [i]));
+            if (param->_have_port_context_id)
+            sensitive << (*(in_RETIRE_CONTEXT_ID     [i]));
+            sensitive << (*(in_RETIRE_EVENT_STATE    [i]))
+                      << (*(in_RETIRE_WRITE_RD       [i]))
+                      << (*(in_RETIRE_WRITE_RE       [i]))
+                      << (*(in_RETIRE_NUM_REG_RD_LOG [i]))
+                      << (*(in_RETIRE_NUM_REG_RE_LOG [i]));
+          }
 # ifdef SYSTEMCASS_SPECIFIC
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Register_Address_Translation_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_allocation.cpp

-              r81
+              r88
       ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RD_PHY_OLD,"num_reg_rd_phy_old",Tgeneral_address_t,_param->_size_general_register);
       ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RE_PHY_OLD,"num_reg_re_phy_old",Tspecial_address_t,_param->_size_special_register);
+      ALLOC1_SIGNAL_OUT(out_RETIRE_RESTORE_RD_PHY_OLD,"restore_rd_phy_old",Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_RETIRE_RESTORE_RE_PHY_OLD,"restore_re_phy_old",Tcontrol_t        ,1);
+    }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     internal_RENAME_ACK = new Tcontrol_t [_param->_nb_inst_insert];
     internal_INSERT_ACK = new Tcontrol_t [_param->_nb_inst_insert];
     internal_RETIRE_ACK = new Tcontrol_t [_param->_nb_inst_retire];
+    rat_gpr              = new Tgeneral_address_t ** [_param->_nb_front_end];
+    rat_gpr_update_table = new bool               ** [_param->_nb_front_end];
+    rat_spr              = new Tspecial_address_t ** [_param->_nb_front_end];
+    rat_spr_update_table = new bool               ** [_param->_nb_front_end];
+    rat_gpr                       = new Tgeneral_address_t ** [_param->_nb_front_end];
+    rat_spr                       = new Tspecial_address_t ** [_param->_nb_front_end];
+    rat_gpr_update_table          = new bool               ** [_param->_nb_front_end];
+    rat_spr_update_table          = new bool               ** [_param->_nb_front_end];
+    internal_rat_gpr_update_table = new bool               ** [_param->_nb_front_end];
+    internal_rat_spr_update_table = new bool               ** [_param->_nb_front_end];
     for (uint32_t i=0; i<_param->_nb_front_end; i++)
+      {
+        rat_gpr              [i] = new Tgeneral_address_t * [_param->_nb_context[i]];
+        rat_gpr_update_table [i] = new bool               * [_param->_nb_context[i]];
+        rat_spr              [i] = new Tspecial_address_t * [_param->_nb_context[i]];
+        rat_spr_update_table [i] = new bool               * [_param->_nb_context[i]];
+        rat_gpr                       [i] = new Tgeneral_address_t * [_param->_nb_context[i]];
+        rat_spr                       [i] = new Tspecial_address_t * [_param->_nb_context[i]];
+        rat_gpr_update_table          [i] = new bool               * [_param->_nb_context[i]];
+        rat_spr_update_table          [i] = new bool               * [_param->_nb_context[i]];
+        internal_rat_gpr_update_table [i] = new bool               * [_param->_nb_context[i]];
+        internal_rat_spr_update_table [i] = new bool               * [_param->_nb_context[i]];
         for (uint32_t j=0; j<_param->_nb_context[i]; j++)
+          {
+            rat_gpr              [i][j] = new Tgeneral_address_t [_param->_nb_general_register_logic];
+            rat_gpr_update_table [i][j] = new bool               [_param->_nb_general_register_logic];
+            rat_spr              [i][j] = new Tspecial_address_t [_param->_nb_special_register_logic];
+            rat_spr_update_table [i][j] = new bool               [_param->_nb_special_register_logic];
+            rat_gpr                       [i][j] = new Tgeneral_address_t [_param->_nb_general_register_logic];
+            rat_spr                       [i][j] = new Tspecial_address_t [_param->_nb_special_register_logic];
+            rat_gpr_update_table          [i][j] = new bool               [_param->_nb_general_register_logic];
+            rat_spr_update_table          [i][j] = new bool               [_param->_nb_special_register_logic];
+            internal_rat_gpr_update_table [i][j] = new bool               [_param->_nb_general_register_logic];
+            internal_rat_spr_update_table [i][j] = new bool               [_param->_nb_special_register_logic];
+          }
+      }
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
 …
         delete []  in_RETIRE_NUM_REG_RD_PHY_OLD;
         delete []  in_RETIRE_NUM_REG_RE_PHY_OLD;
+        delete [] out_RETIRE_RESTORE_RD_PHY_OLD;
+        delete [] out_RETIRE_RESTORE_RE_PHY_OLD;
+        delete [] internal_RENAME_ACK;
+        delete [] internal_INSERT_ACK;
+        delete [] internal_RETIRE_ACK;
+        delete [] rat_gpr             ;
+        delete [] rat_spr             ;
+        delete [] rat_gpr_update_table;
+        delete [] rat_spr_update_table;
+        delete [] internal_rat_gpr_update_table;
+        delete [] internal_rat_spr_update_table;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] internal_RENAME_ACK;
-    delete [] internal_INSERT_ACK;
-    delete [] internal_RETIRE_ACK;
-    delete [] rat_gpr             ;
-    delete [] rat_gpr_update_table;
-    delete [] rat_spr             ;
-    delete [] rat_spr_update_table;
     delete    _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_genMealy_rename.cpp

-              r87
+              r88
 #undef  FUNCTION
 #define FUNCTION "Register_Address_Translation_unit::genMoore"
   void Register_Address_Translation_unit::genMoore (void)
+#define FUNCTION "Register_Address_Translation_unit::genMealy_rename"
+  void Register_Address_Translation_unit::genMealy_rename (void)
+  {
+    log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
+    log_begin(Register_Address_Translation_unit,FUNCTION);
+    log_function(Register_Address_Translation_unit,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
 …
+      }
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"End");
+    log_end(Register_Address_Translation_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit/src/Register_Address_Translation_unit_transition.cpp

-              r81
+              r88
   void Register_Address_Translation_unit::transition (void)
+  {
+    log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"Begin");
+    log_begin(Register_Address_Translation_unit,FUNCTION);
+    log_function(Register_Address_Translation_unit,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
+                    }
+                  // Test if write and have not a previous update
+                  // Test if write and have not a previous update
                   if (PORT_READ(in_RETIRE_WRITE_RD [i]) == 1)
+                    {
                       Tgeneral_address_t rd_log = PORT_READ(in_RETIRE_NUM_REG_RD_LOG [i]);
                       log_printf(NONE,Register_Address_Translation_unit,FUNCTION,"retire[%d]",i);
                       log_printf(NONE,Register_Address_Translation_unit,FUNCTION," * front_end_id : %d",front_end_id);
                       log_printf(NONE,Register_Address_Translation_unit,FUNCTION," * context_id   : %d",context_id  );
                       log_printf(NONE,Register_Address_Translation_unit,FUNCTION," * rd_log       : %d",rd_log      );
+                      log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"  * retire[%d]",i);
+                      log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"    * front_end_id : %d",front_end_id);
+                      log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"    * context_id   : %d",context_id  );
+                      log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"    * rd_log       : %d",rd_log      );
+//                    if (RETIRE_RESTORE_RD_PHY_OLD [i])
                       if (rat_gpr_update_table[front_end_id][context_id][rd_log] == 0)
+                        {
 …
                       Tspecial_address_t re_log = PORT_READ(in_RETIRE_NUM_REG_RE_LOG [i]);
+//                    if (RETIRE_RESTORE_RE_PHY_OLD [i])
                       if (rat_spr_update_table[front_end_id][context_id][re_log] == 0)
+                        {
 …
+      }
+#if (DEBUG >= DEBUG_TRACE) and (DEBUG_Register_Address_Translation_unit == true)
+    log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"  * Dump RAT (Register_Address_Translation_unit)");
+    for (uint32_t i=0; i<_param->_nb_front_end; ++i)
+      for (uint32_t j=0; j<_param->_nb_context[i]; ++j)
+        {
+          log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"    * front_end[%d].context[%d]",i,j);
+          for (uint32_t k=0; k<_param->_nb_general_register_logic; ++k)
+            log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"      * GPR[%.2d] - %.5d %.1d",k,rat_gpr[i][j][k],rat_gpr_update_table[i][j][k]);
+          for (uint32_t k=0; k<_param->_nb_special_register_logic; ++k)
+            log_printf(TRACE,Register_Address_Translation_unit,FUNCTION,"      * SPR[%.2d] - %.5d %.1d",k,rat_spr[i][j][k],rat_spr_update_table[i][j][k]);
+        }
+#endif
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
     end_cycle ();
 #endif
     log_printf(FUNC,Register_Address_Translation_unit,FUNCTION,"End");
+    log_end(Register_Address_Translation_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/SelfTest/Makefile

r81	r88
24	24	library_clean : Register_translation_unit_Glue_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/SelfTest/configuration.cfg

r81	r88
2	2	1 4 *2 # nb_inst_insert
3	3	1 4 *2 # nb_inst_retire
	4	5 5 *2 # size_general_register
	5	2 2 *2 # size_special_register

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/SelfTest/src/main.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/SelfTest/include/test.h"
 #define NB_PARAMS 2
+#define NB_PARAMS 4
 void usage (int argc, char * argv[])
 …
   err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
   err (_("list_params is :\n"));
+  err (_(" * nb_inst_insert (uint32_t)\n"));
+  err (_(" * nb_inst_retire (uint32_t)\n"));
+  err (_(" * nb_inst_insert        (uint32_t)\n"));
+  err (_(" * nb_inst_retire        (uint32_t)\n"));
+  err (_(" * size_general_register (uint32_t)\n"));
+  err (_(" * size_special_register (uint32_t)\n"));
   exit (1);
 …
   string name = argv[x++];
+  uint32_t _nb_inst_insert = atoi(argv[x++]);
+  uint32_t _nb_inst_retire = atoi(argv[x++]);
+  uint32_t _nb_inst_insert        = fromString<uint32_t>(argv[x++]);
+  uint32_t _nb_inst_retire        = fromString<uint32_t>(argv[x++]);
+  uint32_t _size_general_register = fromString<uint32_t>(argv[x++]);
+  uint32_t _size_special_register = fromString<uint32_t>(argv[x++]);
   int _return = EXIT_SUCCESS;
 …
       morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::register_translation_unit_glue::Parameters * param = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::register_translation_unit_glue::Parameters
         (_nb_inst_insert,
+         _nb_inst_retire);
+         _nb_inst_retire,
+         _size_general_register,
+         _size_special_register,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Register_translation_unit_Glue * _Register_translation_unit_Glue = new Register_translation_unit_Glue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_VAL ,"out_INSERT_STAT_LIST_VAL ",Tcontrol_t,_param->_nb_inst_insert);
   ALLOC1_SC_SIGNAL( in_INSERT_STAT_LIST_ACK ," in_INSERT_STAT_LIST_ACK ",Tcontrol_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RA           ," in_INSERT_DEPENDENCY_CHECKING_READ_RA           ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RB           ," in_INSERT_DEPENDENCY_CHECKING_READ_RB           ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RC           ," in_INSERT_DEPENDENCY_CHECKING_READ_RC           ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ," in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ," in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW," in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_READ_RA                     ,"out_INSERT_STAT_LIST_READ_RA                     ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ,"out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_READ_RB                     ,"out_INSERT_STAT_LIST_READ_RB                     ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ,"out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_READ_RC                     ,"out_INSERT_STAT_LIST_READ_RC                     ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ,"out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_WRITE_RD                    ,"out_INSERT_STAT_LIST_WRITE_RD                    ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ,"out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_WRITE_RE                    ,"out_INSERT_STAT_LIST_WRITE_RE                    ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ,"out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_RAT_WRITE_RD                          ,"out_INSERT_RAT_WRITE_RD                          ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RD_LOG                    ,"out_INSERT_RAT_NUM_REG_RD_LOG                    ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ,"out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_RAT_WRITE_RE                          ,"out_INSERT_RAT_WRITE_RE                          ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RE_LOG                    ,"out_INSERT_RAT_NUM_REG_RE_LOG                    ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ,"out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_READ_RA                               ,"out_INSERT_READ_RA                               ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RA_PHY                        ,"out_INSERT_NUM_REG_RA_PHY                        ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_READ_RB                               ,"out_INSERT_READ_RB                               ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RB_PHY                        ,"out_INSERT_NUM_REG_RB_PHY                        ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_READ_RC                               ,"out_INSERT_READ_RC                               ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RC_PHY                        ,"out_INSERT_NUM_REG_RC_PHY                        ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_WRITE_RD                              ,"out_INSERT_WRITE_RD                              ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RD_LOG                        ,"out_INSERT_NUM_REG_RD_LOG                        ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RD_PHY_OLD                    ,"out_INSERT_NUM_REG_RD_PHY_OLD                    ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RD_PHY_NEW                    ,"out_INSERT_NUM_REG_RD_PHY_NEW                    ",Tgeneral_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_WRITE_RE                              ,"out_INSERT_WRITE_RE                              ",Tcontrol_t        ,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RE_LOG                        ,"out_INSERT_NUM_REG_RE_LOG                        ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RE_PHY_OLD                    ,"out_INSERT_NUM_REG_RE_PHY_OLD                    ",Tspecial_address_t,_param->_nb_inst_insert);
+  ALLOC1_SC_SIGNAL(out_INSERT_NUM_REG_RE_PHY_NEW                    ,"out_INSERT_NUM_REG_RE_PHY_NEW                    ",Tspecial_address_t,_param->_nb_inst_insert);
   ALLOC1_SC_SIGNAL( in_RETIRE_VAL           ," in_RETIRE_VAL           ",Tcontrol_t,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL(out_RETIRE_ACK           ,"out_RETIRE_ACK           ",Tcontrol_t,_param->_nb_inst_retire);
 …
   INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_VAL ,_param->_nb_inst_insert);
   INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_STAT_LIST_ACK ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_RETIRE_VAL           ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_RETIRE_ACK           ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_RETIRE_RAT_VAL       ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_RETIRE_RAT_ACK       ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_RETIRE_STAT_LIST_VAL ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_RETIRE_STAT_LIST_ACK ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_READ_RA           ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_READ_RB           ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_READ_RC           ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_READ_RA                     ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_READ_RB                     ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_READ_RC                     ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_WRITE_RD                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_WRITE_RE                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_RAT_WRITE_RD                          ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_RAT_NUM_REG_RD_LOG                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_RAT_WRITE_RE                          ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_RAT_NUM_REG_RE_LOG                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_READ_RA                               ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RA_PHY                        ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_READ_RB                               ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RB_PHY                        ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_READ_RC                               ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RC_PHY                        ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_WRITE_RD                              ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RD_LOG                        ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RD_PHY_OLD                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RD_PHY_NEW                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_WRITE_RE                              ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RE_LOG                        ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RE_PHY_OLD                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_INSERT_NUM_REG_RE_PHY_NEW                    ,_param->_nb_inst_insert);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_RETIRE_VAL          ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_RETIRE_ACK          ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_RETIRE_RAT_VAL      ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_RETIRE_RAT_ACK      ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue,out_RETIRE_STAT_LIST_VAL,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Register_translation_unit_Glue, in_RETIRE_STAT_LIST_ACK,_param->_nb_inst_retire);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
   delete in_NRESET;
+  delete []  in_INSERT_RENAME_VAL    ;
+  delete [] out_INSERT_RENAME_ACK    ;
+  delete [] out_INSERT_INSERT_VAL    ;
+  delete []  in_INSERT_INSERT_ACK    ;
+  delete [] out_INSERT_RAT_INSERT_VAL;
+  delete []  in_INSERT_RAT_RENAME_ACK;
+  delete []  in_INSERT_RAT_INSERT_ACK;
+  delete [] out_INSERT_FREE_LIST_VAL ;
+  delete []  in_INSERT_FREE_LIST_ACK ;
+  delete [] out_INSERT_STAT_LIST_VAL ;
+  delete []  in_INSERT_STAT_LIST_ACK ;
+  delete []  in_RETIRE_VAL           ;
+  delete [] out_RETIRE_ACK           ;
+  delete [] out_RETIRE_RAT_VAL       ;
+  delete []  in_RETIRE_RAT_ACK       ;
+  delete [] out_RETIRE_STAT_LIST_VAL ;
+  delete []  in_RETIRE_STAT_LIST_ACK ;
+  DELETE1_SC_SIGNAL( in_INSERT_RENAME_VAL    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RENAME_ACK    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_INSERT_VAL    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_INSERT_ACK    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_INSERT_VAL,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_RAT_RENAME_ACK,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_RAT_INSERT_ACK,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_FREE_LIST_VAL ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_FREE_LIST_ACK ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_VAL ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_STAT_LIST_ACK ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RA           ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RB           ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RC           ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_READ_RA                     ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_READ_RB                     ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_READ_RC                     ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_WRITE_RD                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_WRITE_RE                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_WRITE_RD                          ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RD_LOG                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_WRITE_RE                          ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RE_LOG                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_READ_RA                               ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RA_PHY                        ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_READ_RB                               ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RB_PHY                        ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_READ_RC                               ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RC_PHY                        ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_WRITE_RD                              ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RD_LOG                        ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RD_PHY_OLD                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RD_PHY_NEW                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_WRITE_RE                              ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RE_LOG                        ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RE_PHY_OLD                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL(out_INSERT_NUM_REG_RE_PHY_NEW                    ,_param->_nb_inst_insert);
+  DELETE1_SC_SIGNAL( in_RETIRE_VAL          ,_param->_nb_inst_retire);
+  DELETE1_SC_SIGNAL(out_RETIRE_ACK          ,_param->_nb_inst_retire);
+  DELETE1_SC_SIGNAL(out_RETIRE_RAT_VAL      ,_param->_nb_inst_retire);
+  DELETE1_SC_SIGNAL( in_RETIRE_RAT_ACK      ,_param->_nb_inst_retire);
+  DELETE1_SC_SIGNAL(out_RETIRE_STAT_LIST_VAL,_param->_nb_inst_retire);
+  DELETE1_SC_SIGNAL( in_RETIRE_STAT_LIST_ACK,_param->_nb_inst_retire);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/include/Parameters.h

-              r82
+              r88
   public : uint32_t _nb_inst_insert;
   public : uint32_t _nb_inst_retire;
+//public : uint32_t _size_general_register;
+//public : uint32_t _size_special_register;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t nb_inst_insert,
+                        uint32_t nb_inst_retire);
+                        uint32_t nb_inst_retire,
+                        uint32_t size_general_register,
+                        uint32_t size_special_register,
+                        bool     is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/include/Register_translation_unit_Glue.h

-              r82
+              r88
     // ~~~~~[ Interface : "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_RENAME_VAL    ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_RENAME_ACK    ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_INSERT_VAL    ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_INSERT_ACK    ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_RAT_INSERT_VAL;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_RAT_RENAME_ACK;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_RAT_INSERT_ACK;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_FREE_LIST_VAL ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_FREE_LIST_ACK ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_STAT_LIST_VAL ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_STAT_LIST_ACK ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_RENAME_VAL                            ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_RENAME_ACK                            ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_INSERT_VAL                            ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_INSERT_ACK                            ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_RAT_INSERT_VAL                        ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_RAT_RENAME_ACK                        ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_RAT_INSERT_ACK                        ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_FREE_LIST_VAL                         ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_FREE_LIST_ACK                         ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t)           ** out_INSERT_STAT_LIST_VAL                         ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t)           **  in_INSERT_STAT_LIST_ACK                         ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t        )   **  in_INSERT_DEPENDENCY_CHECKING_READ_RA           ;//[nb_inst_insert]
+  public    : SC_IN (Tgeneral_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t        )   **  in_INSERT_DEPENDENCY_CHECKING_READ_RB           ;//[nb_inst_insert]
+  public    : SC_IN (Tgeneral_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t        )   **  in_INSERT_DEPENDENCY_CHECKING_READ_RC           ;//[nb_inst_insert]
+  public    : SC_IN (Tspecial_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t        )   **  in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ;//[nb_inst_insert]
+  public    : SC_IN (Tgeneral_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ;//[nb_inst_insert]
+  public    : SC_IN (Tgeneral_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD;//[nb_inst_insert]
+  public    : SC_IN (Tgeneral_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW;//[nb_inst_insert]
+  public    : SC_IN (Tcontrol_t        )   **  in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ;//[nb_inst_insert]
+  public    : SC_IN (Tspecial_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ;//[nb_inst_insert]
+  public    : SC_IN (Tspecial_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD;//[nb_inst_insert]
+  public    : SC_IN (Tspecial_address_t)   **  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_STAT_LIST_READ_RA                     ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_STAT_LIST_READ_RB                     ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_STAT_LIST_READ_RC                     ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_STAT_LIST_WRITE_RD                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_STAT_LIST_WRITE_RE                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_RAT_WRITE_RD                          ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_RAT_NUM_REG_RD_LOG                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_RAT_WRITE_RE                          ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_RAT_NUM_REG_RE_LOG                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_READ_RA                               ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_NUM_REG_RA_PHY                        ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_READ_RB                               ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_NUM_REG_RB_PHY                        ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_READ_RC                               ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_NUM_REG_RC_PHY                        ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_WRITE_RD                              ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_NUM_REG_RD_LOG                        ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_NUM_REG_RD_PHY_OLD                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tgeneral_address_t)   ** out_INSERT_NUM_REG_RD_PHY_NEW                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tcontrol_t        )   ** out_INSERT_WRITE_RE                              ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_NUM_REG_RE_LOG                        ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_NUM_REG_RE_PHY_OLD                    ;//[nb_inst_insert]
+  public    : SC_OUT(Tspecial_address_t)   ** out_INSERT_NUM_REG_RE_PHY_NEW                    ;//[nb_inst_insert]
     // ~~~~~[ Interface : "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public  : void        transition                (void);
 # endif
+  public  : void        genMealy_insert_valack    (void);
   public  : void        genMealy_insert           (void);
   public  : void        genMealy_retire           (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Parameters.cpp

-              r81
+              r88
 #define FUNCTION "Register_translation_unit_Glue::Parameters"
   Parameters::Parameters (uint32_t nb_inst_insert,
+                          uint32_t nb_inst_retire)
+                          uint32_t nb_inst_retire,
+                          uint32_t size_general_register,
+                          uint32_t size_special_register,
+                          bool     is_toplevel)
+  {
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
     _nb_inst_insert = nb_inst_insert;
     _nb_inst_retire = nb_inst_retire;
+    _nb_inst_insert        = nb_inst_insert;
+    _nb_inst_retire        = nb_inst_retire;
     test();
+    if (is_toplevel)
+      {
+        _size_general_register = size_general_register;
+        _size_special_register = size_special_register;
+        copy ();
+      }
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"End");
   };
 …
 #undef  FUNCTION
 #define FUNCTION "Register_translation_unit_Glue::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
+    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Register_translation_unit_Glue::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Parameters_print.cpp

-              r81
+              r88
     xml.balise_open("register_translation_unit_glue");
+    xml.singleton_begin("nb_inst_insert"); xml.attribut("value",toString(_nb_inst_insert)); xml.singleton_end();
+    xml.singleton_begin("nb_inst_retire"); xml.attribut("value",toString(_nb_inst_retire)); xml.singleton_end();
+    xml.singleton_begin("nb_inst_insert       "); xml.attribut("value",toString(_nb_inst_insert       )); xml.singleton_end();
+    xml.singleton_begin("nb_inst_retire       "); xml.attribut("value",toString(_nb_inst_retire       )); xml.singleton_end();
+    xml.singleton_begin("size_general_register"); xml.attribut("value",toString(_size_general_register)); xml.singleton_end();
+    xml.singleton_begin("size_special_register"); xml.attribut("value",toString(_size_special_register)); xml.singleton_end();
     xml.balise_close();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue.cpp

-              r81
+              r88
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
+#if DEBUG_Register_translation_unit_Glue == true
+    log_printf(INFO,Register_translation_unit_Glue,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Method - transition");
 …
         SC_METHOD (genMealy_retire);
         dont_initialize ();
 //      sensitive << (*(in_CLOCK)).neg();
+//      sensitive << (*(in_CLOCK)).neg(); // don't need internal register
         for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
           sensitive << (*(in_RETIRE_VAL           [i]))
 …
 # endif
         log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Method - genMealy_insert");
         SC_METHOD (genMealy_insert);
         dont_initialize ();
 //      sensitive << (*(in_CLOCK)).neg();
+        log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Method - genMealy_insert_valack");
+        SC_METHOD (genMealy_insert_valack);
+        dont_initialize ();
+//      sensitive << (*(in_CLOCK)).neg(); // don't need internal register
         for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
           sensitive << (*(in_INSERT_RENAME_VAL     [i]))
 …
+          }
 # endif
+        log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Method - genMealy_insert");
+        SC_METHOD (genMealy_insert);
+        dont_initialize ();
+//      sensitive << (*(in_CLOCK)).neg(); // don't need internal register
+        for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+          sensitive << (*(in_INSERT_DEPENDENCY_CHECKING_READ_RA            [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY     [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_READ_RB            [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY     [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_READ_RC            [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY     [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_WRITE_RD           [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG     [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_WRITE_RE           [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG     [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD [i]))
+                    << (*(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW [i]));
+# ifdef SYSTEMCASS_SPECIFIC
+        // List dependency information
+# endif
 #endif
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Register_translation_unit_Glue,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_allocation.cpp

-              r81
+              r88
       ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_VAL ,"stat_list_val" ,Tcontrol_t,1);
       ALLOC1_SIGNAL_IN ( in_INSERT_STAT_LIST_ACK ,"stat_list_ack" ,Tcontrol_t,1);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_READ_RA           ,"DEPENDENCY_CHECKING_READ_RA"           ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ,"DEPENDENCY_CHECKING_NUM_REG_RA_PHY"    ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_READ_RB           ,"DEPENDENCY_CHECKING_READ_RB"           ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ,"DEPENDENCY_CHECKING_NUM_REG_RB_PHY"    ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_READ_RC           ,"DEPENDENCY_CHECKING_READ_RC"           ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ,"DEPENDENCY_CHECKING_NUM_REG_RC_PHY"    ,Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ,"DEPENDENCY_CHECKING_WRITE_RD"          ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ,"DEPENDENCY_CHECKING_NUM_REG_RD_LOG"    ,Tgeneral_address_t,_param->_size_general_register_logic);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD,"DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD",Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW,"DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW",Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ,"DEPENDENCY_CHECKING_WRITE_RE"          ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ,"DEPENDENCY_CHECKING_NUM_REG_RE_LOG"    ,Tspecial_address_t,_param->_size_special_register_logic);
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD,"DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD",Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_IN ( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW,"DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW",Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_READ_RA                     ,"STAT_LIST_READ_RA"                     ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ,"STAT_LIST_NUM_REG_RA_PHY"              ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_READ_RB                     ,"STAT_LIST_READ_RB"                     ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ,"STAT_LIST_NUM_REG_RB_PHY"              ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_READ_RC                     ,"STAT_LIST_READ_RC"                     ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ,"STAT_LIST_NUM_REG_RC_PHY"              ,Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_WRITE_RD                    ,"STAT_LIST_WRITE_RD"                    ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ,"STAT_LIST_NUM_REG_RD_PHY_NEW"          ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_WRITE_RE                    ,"STAT_LIST_WRITE_RE"                    ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ,"STAT_LIST_NUM_REG_RE_PHY_NEW"          ,Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_RAT_WRITE_RD                          ,"RAT_WRITE_RD"                          ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_RAT_NUM_REG_RD_LOG                    ,"RAT_NUM_REG_RD_LOG"                    ,Tgeneral_address_t,_param->_size_general_register_logic);
+      ALLOC1_SIGNAL_OUT(out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ,"RAT_NUM_REG_RD_PHY_NEW"                ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_RAT_WRITE_RE                          ,"RAT_WRITE_RE"                          ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_RAT_NUM_REG_RE_LOG                    ,"RAT_NUM_REG_RE_LOG"                    ,Tspecial_address_t,_param->_size_special_register_logic);
+      ALLOC1_SIGNAL_OUT(out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ,"RAT_NUM_REG_RE_PHY_NEW"                ,Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_READ_RA                               ,"READ_RA"                               ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RA_PHY                        ,"NUM_REG_RA_PHY"                        ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_READ_RB                               ,"READ_RB"                               ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RB_PHY                        ,"NUM_REG_RB_PHY"                        ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_READ_RC                               ,"READ_RC"                               ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RC_PHY                        ,"NUM_REG_RC_PHY"                        ,Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_WRITE_RD                              ,"WRITE_RD"                              ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RD_LOG                        ,"NUM_REG_RD_LOG"                        ,Tgeneral_address_t,_param->_size_general_register_logic);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RD_PHY_OLD                    ,"NUM_REG_RD_PHY_OLD"                    ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RD_PHY_NEW                    ,"NUM_REG_RD_PHY_NEW"                    ,Tgeneral_address_t,_param->_size_general_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_WRITE_RE                              ,"WRITE_RE"                              ,Tcontrol_t        ,1);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RE_LOG                        ,"NUM_REG_RE_LOG"                        ,Tspecial_address_t,_param->_size_special_register_logic);
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RE_PHY_OLD                    ,"NUM_REG_RE_PHY_OLD"                    ,Tspecial_address_t,_param->_size_special_register      );
+      ALLOC1_SIGNAL_OUT(out_INSERT_NUM_REG_RE_PHY_NEW                    ,"NUM_REG_RE_PHY_NEW"                    ,Tspecial_address_t,_param->_size_special_register      );
+    }
 …
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_deallocation.cpp

-              r81
+              r88
 #include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/include/Register_translation_unit_Glue.h"
+#include "Behavioural/include/Allocation.h"
 namespace morpheo                    {
 …
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
         delete     in_NRESET;
+        delete []  in_INSERT_RENAME_VAL    ;
+        delete [] out_INSERT_RENAME_ACK    ;
+        delete [] out_INSERT_INSERT_VAL    ;
+        delete []  in_INSERT_INSERT_ACK    ;
+        delete [] out_INSERT_RAT_INSERT_VAL;
+        delete []  in_INSERT_RAT_RENAME_ACK;
+        delete []  in_INSERT_RAT_INSERT_ACK;
+        delete [] out_INSERT_FREE_LIST_VAL ;
+        delete []  in_INSERT_FREE_LIST_ACK ;
+        delete [] out_INSERT_STAT_LIST_VAL ;
+        delete []  in_INSERT_STAT_LIST_ACK ;
+        DELETE1_SIGNAL( in_INSERT_RENAME_VAL    ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_RENAME_ACK    ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_INSERT_VAL    ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_INSERT_ACK    ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_RAT_INSERT_VAL,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_RAT_RENAME_ACK,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_RAT_INSERT_ACK,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_FREE_LIST_VAL ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_FREE_LIST_ACK ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_VAL ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_STAT_LIST_ACK ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RA           ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY    ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RB           ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY    ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_READ_RC           ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY    ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_WRITE_RD          ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG    ,_param->_nb_inst_insert,_param->_size_general_register_logic);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_WRITE_RE          ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG    ,_param->_nb_inst_insert,_param->_size_special_register_logic);
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL( in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_READ_RA                     ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RA_PHY              ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_READ_RB                     ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RB_PHY              ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_READ_RC                     ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RC_PHY              ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_WRITE_RD                    ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW          ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_WRITE_RE                    ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW          ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL(out_INSERT_RAT_WRITE_RD                          ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_RAT_NUM_REG_RD_LOG                    ,_param->_nb_inst_insert,_param->_size_general_register_logic);
+        DELETE1_SIGNAL(out_INSERT_RAT_NUM_REG_RD_PHY_NEW                ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_RAT_WRITE_RE                          ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_RAT_NUM_REG_RE_LOG                    ,_param->_nb_inst_insert,_param->_size_special_register_logic);
+        DELETE1_SIGNAL(out_INSERT_RAT_NUM_REG_RE_PHY_NEW                ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL(out_INSERT_READ_RA                               ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RA_PHY                        ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_READ_RB                               ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RB_PHY                        ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_READ_RC                               ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RC_PHY                        ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL(out_INSERT_WRITE_RD                              ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RD_LOG                        ,_param->_nb_inst_insert,_param->_size_general_register_logic);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RD_PHY_OLD                    ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RD_PHY_NEW                    ,_param->_nb_inst_insert,_param->_size_general_register      );
+        DELETE1_SIGNAL(out_INSERT_WRITE_RE                              ,_param->_nb_inst_insert,1);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RE_LOG                        ,_param->_nb_inst_insert,_param->_size_special_register_logic);
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RE_PHY_OLD                    ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL(out_INSERT_NUM_REG_RE_PHY_NEW                    ,_param->_nb_inst_insert,_param->_size_special_register      );
+        DELETE1_SIGNAL( in_RETIRE_VAL          ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_ACK          ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_RAT_VAL      ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL( in_RETIRE_RAT_ACK      ,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL(out_RETIRE_STAT_LIST_VAL,_param->_nb_inst_retire,1);
+        DELETE1_SIGNAL( in_RETIRE_STAT_LIST_ACK,_param->_nb_inst_retire,1);
-        delete []  in_RETIRE_VAL           ;
-        delete [] out_RETIRE_ACK           ;
-        delete [] out_RETIRE_RAT_VAL       ;
-        delete []  in_RETIRE_RAT_ACK       ;
-        delete [] out_RETIRE_STAT_LIST_VAL ;
-        delete []  in_RETIRE_STAT_LIST_ACK ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_insert.cpp

-              r81
+              r88
   void Register_translation_unit_Glue::genMealy_insert (void)
+  {
+    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_translation_unit_Glue,FUNCTION);
+    log_function(Register_translation_unit_Glue,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+      {
+        Tcontrol_t rename_val     = PORT_READ(in_INSERT_RENAME_VAL     [i]);
+        Tcontrol_t insert_ack     = PORT_READ(in_INSERT_INSERT_ACK     [i]);
+        Tcontrol_t rat_rename_ack = PORT_READ(in_INSERT_RAT_RENAME_ACK [i]);
+        Tcontrol_t rat_insert_ack = PORT_READ(in_INSERT_RAT_INSERT_ACK [i]);
+        Tcontrol_t free_list_ack  = PORT_READ(in_INSERT_FREE_LIST_ACK  [i]);
+        Tcontrol_t stat_list_ack  = PORT_READ(in_INSERT_STAT_LIST_ACK  [i]);
+        Tcontrol_t         READ_RA            = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_READ_RA            [i]);
+        Tgeneral_address_t NUM_REG_RA_PHY     = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY     [i]);
+        Tcontrol_t         READ_RB            = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_READ_RB            [i]);
+        Tgeneral_address_t NUM_REG_RB_PHY     = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY     [i]);
+        Tcontrol_t         READ_RC            = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_READ_RC            [i]);
+        Tspecial_address_t NUM_REG_RC_PHY     = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY     [i]);
+        Tcontrol_t         WRITE_RD           = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_WRITE_RD           [i]);
+        Tgeneral_address_t NUM_REG_RD_LOG     = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG     [i]);
+        Tgeneral_address_t NUM_REG_RD_PHY_OLD = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD [i]);
+        Tgeneral_address_t NUM_REG_RD_PHY_NEW = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW [i]);
+        Tcontrol_t         WRITE_RE           = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_WRITE_RE           [i]);
+        Tspecial_address_t NUM_REG_RE_LOG     = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG     [i]);
+        Tspecial_address_t NUM_REG_RE_PHY_OLD = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD [i]);
+        Tspecial_address_t NUM_REG_RE_PHY_NEW = PORT_READ(in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW [i]);
+        PORT_WRITE(out_INSERT_RENAME_ACK     [i], (insert_ack     and
+                                                   rat_rename_ack and
+                                                   rat_insert_ack and
+                                                   free_list_ack  and
+                                                   stat_list_ack  ));
+        PORT_WRITE(out_INSERT_INSERT_VAL     [i], (rename_val     and
+                                                   rat_rename_ack and
+                                                   rat_insert_ack and
+                                                   free_list_ack  and
+                                                   stat_list_ack  ));
+        PORT_WRITE(out_INSERT_RAT_INSERT_VAL [i], (rename_val     and
+                                                   insert_ack     and
+                                                   rat_rename_ack and
+                                                   free_list_ack  and
+                                                   stat_list_ack  ));
+        PORT_WRITE(out_INSERT_FREE_LIST_VAL  [i], (rename_val     and
+                                                   insert_ack     and
+                                                   rat_rename_ack and
+                                                   rat_insert_ack and
+                                                   stat_list_ack  ));
+        PORT_WRITE(out_INSERT_STAT_LIST_VAL  [i], (rename_val     and
+                                                   insert_ack     and
+                                                   rat_rename_ack and
+                                                   rat_insert_ack and
+                                                   free_list_ack  ));
+        PORT_WRITE(out_INSERT_STAT_LIST_READ_RA            [i], READ_RA           );
+        PORT_WRITE(out_INSERT_STAT_LIST_NUM_REG_RA_PHY     [i], NUM_REG_RA_PHY    );
+        PORT_WRITE(out_INSERT_STAT_LIST_READ_RB            [i], READ_RB           );
+        PORT_WRITE(out_INSERT_STAT_LIST_NUM_REG_RB_PHY     [i], NUM_REG_RB_PHY    );
+        PORT_WRITE(out_INSERT_STAT_LIST_READ_RC            [i], READ_RC           );
+        PORT_WRITE(out_INSERT_STAT_LIST_NUM_REG_RC_PHY     [i], NUM_REG_RC_PHY    );
+        PORT_WRITE(out_INSERT_STAT_LIST_WRITE_RD           [i], WRITE_RD          );
+        PORT_WRITE(out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW [i], NUM_REG_RD_PHY_NEW);
+        PORT_WRITE(out_INSERT_STAT_LIST_WRITE_RE           [i], WRITE_RE          );
+        PORT_WRITE(out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW [i], NUM_REG_RE_PHY_NEW);
+        PORT_WRITE(out_INSERT_RAT_WRITE_RD                 [i], WRITE_RD          );
+        PORT_WRITE(out_INSERT_RAT_NUM_REG_RD_LOG           [i], NUM_REG_RD_LOG    );
+        PORT_WRITE(out_INSERT_RAT_NUM_REG_RD_PHY_NEW       [i], NUM_REG_RD_PHY_NEW);
+        PORT_WRITE(out_INSERT_RAT_WRITE_RE                 [i], WRITE_RE          );
+        PORT_WRITE(out_INSERT_RAT_NUM_REG_RE_LOG           [i], NUM_REG_RE_LOG    );
+        PORT_WRITE(out_INSERT_RAT_NUM_REG_RE_PHY_NEW       [i], NUM_REG_RE_PHY_NEW);
+        PORT_WRITE(out_INSERT_READ_RA                      [i], READ_RA           );
+        PORT_WRITE(out_INSERT_NUM_REG_RA_PHY               [i], NUM_REG_RA_PHY    );
+        PORT_WRITE(out_INSERT_READ_RB                      [i], READ_RB           );
+        PORT_WRITE(out_INSERT_NUM_REG_RB_PHY               [i], NUM_REG_RB_PHY    );
+        PORT_WRITE(out_INSERT_READ_RC                      [i], READ_RC           );
+        PORT_WRITE(out_INSERT_NUM_REG_RC_PHY               [i], NUM_REG_RC_PHY    );
+        PORT_WRITE(out_INSERT_WRITE_RD                     [i], WRITE_RD          );
+        PORT_WRITE(out_INSERT_NUM_REG_RD_LOG               [i], NUM_REG_RD_LOG    );
+        PORT_WRITE(out_INSERT_NUM_REG_RD_PHY_OLD           [i], NUM_REG_RD_PHY_OLD);
+        PORT_WRITE(out_INSERT_NUM_REG_RD_PHY_NEW           [i], NUM_REG_RD_PHY_NEW);
+        PORT_WRITE(out_INSERT_WRITE_RE                     [i], WRITE_RE          );
+        PORT_WRITE(out_INSERT_NUM_REG_RE_LOG               [i], NUM_REG_RE_LOG    );
+        PORT_WRITE(out_INSERT_NUM_REG_RE_PHY_OLD           [i], NUM_REG_RE_PHY_OLD);
+        PORT_WRITE(out_INSERT_NUM_REG_RE_PHY_NEW           [i], NUM_REG_RE_PHY_NEW);
+      }
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"End");
+    log_end(Register_translation_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue/src/Register_translation_unit_Glue_genMealy_retire.cpp

-              r81
+              r88
   void Register_translation_unit_Glue::genMealy_retire (void)
+  {
+    log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"Begin");
+    log_begin(Register_translation_unit_Glue,FUNCTION);
+    log_function(Register_translation_unit_Glue,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
 …
+      }
     log_printf(FUNC,Register_translation_unit_Glue,FUNCTION,"End");
+    log_end(Register_translation_unit_Glue,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Register_translation_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_reg_free           ,
          _nb_bank               ,
+         _size_read_counter     );
+         _size_read_counter     ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Register_translation_unit * _Register_translation_unit = new Register_translation_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/SelfTest/Makefile

r81	r88
24	24	library_clean : Stat_List_unit_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/SelfTest/src/main.cpp

-              r81
+              r88
          _nb_reg_free           ,
          _nb_bank               ,
+         _size_counter          );
+         _size_counter          ,
+         true //is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Stat_List_unit * _Stat_List_unit = new Stat_List_unit
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RC_PHY    ," in_RETIRE_NUM_REG_RC_PHY    ",Tspecial_address_t,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_WRITE_RD          ," in_RETIRE_WRITE_RD          ",Tcontrol_t        ,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL( in_RETIRE_RESTORE_RD_PHY_OLD," in_RETIRE_RESTORE_RD_PHY_OLD",Tcontrol_t        ,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RD_PHY_OLD," in_RETIRE_NUM_REG_RD_PHY_OLD",Tgeneral_address_t,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RD_PHY_NEW," in_RETIRE_NUM_REG_RD_PHY_NEW",Tgeneral_address_t,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_WRITE_RE          ," in_RETIRE_WRITE_RE          ",Tcontrol_t        ,_param->_nb_inst_retire);
+  ALLOC1_SC_SIGNAL( in_RETIRE_RESTORE_RE_PHY_OLD," in_RETIRE_RESTORE_RE_PHY_OLD",Tcontrol_t        ,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RE_PHY_OLD," in_RETIRE_NUM_REG_RE_PHY_OLD",Tspecial_address_t,_param->_nb_inst_retire);
   ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RE_PHY_NEW," in_RETIRE_NUM_REG_RE_PHY_NEW",Tspecial_address_t,_param->_nb_inst_retire);
 …
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RC_PHY    ,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_WRITE_RD          ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_RESTORE_RD_PHY_OLD,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RD_PHY_OLD,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RD_PHY_NEW,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_WRITE_RE          ,_param->_nb_inst_retire);
+  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_RESTORE_RE_PHY_OLD,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RE_PHY_OLD,_param->_nb_inst_retire);
   INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RE_PHY_NEW,_param->_nb_inst_retire);
 …
               in_RETIRE_NUM_REG_RC_PHY     [i]->write(rc);
               in_RETIRE_WRITE_RD           [i]->write(write_rd);
+              in_RETIRE_RESTORE_RD_PHY_OLD [i]->write(0);
               in_RETIRE_NUM_REG_RD_PHY_OLD [i]->write(rd_old);
               in_RETIRE_NUM_REG_RD_PHY_NEW [i]->write(rd_new);
               in_RETIRE_WRITE_RE           [i]->write(write_re);
+              in_RETIRE_RESTORE_RE_PHY_OLD [i]->write(0);
               in_RETIRE_NUM_REG_RE_PHY_OLD [i]->write(re_old);
               in_RETIRE_NUM_REG_RE_PHY_NEW [i]->write(re_new);
 …
             if (in_RETIRE_VAL [i]->read() and out_RETIRE_ACK [i]->read())
+              {
+                Tcontrol_t         read_ra  = in_RETIRE_READ_RA            [i]->read();
+                Tgeneral_address_t ra       = in_RETIRE_NUM_REG_RA_PHY     [i]->read();
+                Tcontrol_t         read_rb  = in_RETIRE_READ_RB            [i]->read();
+                Tgeneral_address_t rb       = in_RETIRE_NUM_REG_RB_PHY     [i]->read();
+                Tcontrol_t         read_rc  = in_RETIRE_READ_RC            [i]->read();
+                Tspecial_address_t rc       = in_RETIRE_NUM_REG_RC_PHY     [i]->read();
+                Tcontrol_t         write_rd = in_RETIRE_WRITE_RD           [i]->read();
+                Tgeneral_address_t rd_old   = in_RETIRE_NUM_REG_RD_PHY_OLD [i]->read();
+                Tgeneral_address_t rd_new   = in_RETIRE_NUM_REG_RD_PHY_NEW [i]->read();
+                Tcontrol_t         write_re = in_RETIRE_WRITE_RE           [i]->read();
+                Tgeneral_address_t re_old   = in_RETIRE_NUM_REG_RE_PHY_OLD [i]->read();
+                Tgeneral_address_t re_new   = in_RETIRE_NUM_REG_RE_PHY_NEW [i]->read();
+                Tcontrol_t         read_ra        = in_RETIRE_READ_RA            [i]->read();
+                Tgeneral_address_t ra             = in_RETIRE_NUM_REG_RA_PHY     [i]->read();
+                Tcontrol_t         read_rb        = in_RETIRE_READ_RB            [i]->read();
+                Tgeneral_address_t rb             = in_RETIRE_NUM_REG_RB_PHY     [i]->read();
+                Tcontrol_t         read_rc        = in_RETIRE_READ_RC            [i]->read();
+                Tspecial_address_t rc             = in_RETIRE_NUM_REG_RC_PHY     [i]->read();
+                Tcontrol_t         write_rd       = in_RETIRE_WRITE_RD           [i]->read();
+                Tcontrol_t         restore_rd_old = in_RETIRE_RESTORE_RD_PHY_OLD [i]->read();
+                Tgeneral_address_t rd_old         = in_RETIRE_NUM_REG_RD_PHY_OLD [i]->read();
+                Tgeneral_address_t rd_new         = in_RETIRE_NUM_REG_RD_PHY_NEW [i]->read();
+                Tcontrol_t         write_re       = in_RETIRE_WRITE_RE           [i]->read();
+                Tcontrol_t         restore_re_old = in_RETIRE_RESTORE_RE_PHY_OLD [i]->read();
+                Tgeneral_address_t re_old         = in_RETIRE_NUM_REG_RE_PHY_OLD [i]->read();
+                Tgeneral_address_t re_new         = in_RETIRE_NUM_REG_RE_PHY_NEW [i]->read();
                 LABEL("RETIRE [%d] - Accepted",i);
 …
                 LABEL("   * status[%d]._counter  : %d",rc,spr_status[rc]._counter );
                 LABEL(" * read_rd          : %d",write_rd);
+                LABEL(" * restore_rd_old   : %d",restore_rd_old);
                 LABEL(" * reg_rd_old       : %d",rd_old  );
                 LABEL("   * status[%d]._is_free  : %d",rd_old,spr_status[rd_old]._is_free );
 …
                 LABEL("   * status[%d]._counter  : %d",rd_new,spr_status[rd_new]._counter );
                 LABEL(" * read_re          : %d",write_re);
+                LABEL(" * restore_re_old   : %d",restore_re_old);
                 LABEL(" * reg_re_old       : %d",re_old  );
                 LABEL("   * status[%d]._is_free  : %d",re_old,spr_status[re_old]._is_free );
 …
                 if (write_rd)
+                  {
+                    gpr_status[rd_old]._is_link  = 0;
+                    gpr_status[rd_new]._is_valid = 1;
+                    if (restore_rd_old)
+                      {
+                        gpr_status[rd_old]._is_link  = 1;
+                        gpr_status[rd_new]._is_link  = 0;
+                        gpr_status[rd_new]._is_valid = 1;
+                      }
+                    else
+                      {
+                        gpr_status[rd_old]._is_link  = 0;
+                        gpr_status[rd_new]._is_valid = 1;
+                      }
+                  }
                 if (write_re)
+                  {
+                    spr_status[re_old]._is_link  = 0;
+                    spr_status[re_new]._is_valid = 1;
+                  }
+                    if (restore_re_old)
+                      {
+                        spr_status[re_old]._is_link  = 1;
+                        spr_status[re_new]._is_link  = 0;
+                        spr_status[re_new]._is_valid = 1;
+                      }
+                    else
+                      {
+                        spr_status[re_old]._is_link  = 0;
+                        spr_status[re_new]._is_valid = 1;
+                      }
+                  }
+              }
 …
   delete []  in_RETIRE_NUM_REG_RC_PHY    ;
   delete []  in_RETIRE_WRITE_RD          ;
+  delete []  in_RETIRE_RESTORE_RD_PHY_OLD;
   delete []  in_RETIRE_NUM_REG_RD_PHY_OLD;
   delete []  in_RETIRE_NUM_REG_RD_PHY_NEW;
   delete []  in_RETIRE_WRITE_RE          ;
+  delete []  in_RETIRE_RESTORE_RE_PHY_OLD;
   delete []  in_RETIRE_NUM_REG_RE_PHY_OLD;
   delete []  in_RETIRE_NUM_REG_RE_PHY_NEW;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Parameters.h

-              r82
+              r88
   public : uint32_t   _size_counter          ;
   public : uint32_t   _size_general_register ;
   public : uint32_t   _size_special_register ;
+//public : uint32_t   _size_general_register ;
+//public : uint32_t   _size_special_register ;
   public : uint32_t   _max_reader            ;
 …
                         uint32_t   nb_reg_free           ,
                         uint32_t   nb_bank               ,
+                        uint32_t   size_counter          );
+                        uint32_t   size_counter          ,
+                        bool       is_toplevel=false
+                        );
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Stat_List_unit.h

-              r82
+              r88
 #ifndef morpheo_behavioural_core_multi_ooo_engine_ooo_engine_rename_unit_register_translation_unit_stat_list_unit_Stat_List_unit_h
+ #ifndef morpheo_behavioural_core_multi_ooo_engine_ooo_engine_rename_unit_register_translation_unit_stat_list_unit_Stat_List_unit_h
 #define morpheo_behavioural_core_multi_ooo_engine_ooo_engine_rename_unit_register_translation_unit_stat_list_unit_Stat_List_unit_h
 …
   public    : SC_IN (Tspecial_address_t)   **  in_RETIRE_NUM_REG_RC_PHY    ;//[nb_inst_retire]
   public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_WRITE_RD          ;//[nb_inst_retire]
+  public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_RESTORE_RD_PHY_OLD;//[nb_inst_retire]
   public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RD_PHY_OLD;//[nb_inst_retire]
   public    : SC_IN (Tgeneral_address_t)   **  in_RETIRE_NUM_REG_RD_PHY_NEW;//[nb_inst_retire]
   public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_WRITE_RE          ;//[nb_inst_retire]
+  public    : SC_IN (Tcontrol_t        )   **  in_RETIRE_RESTORE_RE_PHY_OLD;//[nb_inst_retire]
   public    : SC_IN (Tspecial_address_t)   **  in_RETIRE_NUM_REG_RE_PHY_OLD;//[nb_inst_retire]
   public    : SC_IN (Tspecial_address_t)   **  in_RETIRE_NUM_REG_RE_PHY_NEW;//[nb_inst_retire]

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/include/Types.h

-              r81
+              r88
   class stat_list_entry_t
+  {
   private : bool     _is_free ; // set = is present in free list
   private : bool     _is_link ; // set = is present in rat
   private : bool     _is_valid; // set = an instruction have write in this register
   private : uint32_t _counter ; // number of register that must read this register
+  public : bool     _is_free ; // set = is present in free list
+  public : bool     _is_link ; // set = is present in rat
+  public : bool     _is_valid; // set = an instruction have write in this register
+  public : uint32_t _counter ; // number of register that must read this register
   public :  stat_list_entry_t (void) {};
 …
+    }
   public : void retire_write_old (void)
+  public : void retire_write_old (bool restore_old)
+    {
+      _is_link  = 0;
+      if (not restore_old)
+        {
+          _is_link  = 0;
+        }
+      // else nothing
+    }
   public : void retire_write_new (void)
+  public : void retire_write_new (bool restore_old)
+    {
+      if (restore_old)
+        {
+          _is_link  = 0;
+        }
+      // in all case
       _is_valid = 1;
+    }
 …
       return ((_is_free  == 0) and
               (_is_link  == 0) and
+              (_is_valid == 1) and
+//            (_is_valid == 1) and // if is_link <- 0, then retire_write_old or reset
               (_counter  == 0));
+    }
   public : friend std::ostream& operator<< (std::ostream& output_stream,
+  public : friend std::ostream& operator<< (std::ostream& output,
                                             stat_list_entry_t & x)
+    {
       output_stream << x._is_free  << " "
                     << x._is_link  << " "
                     << x._is_valid << " "
                     << x._counter;
+      output << x._is_free  << " "
+             << x._is_link  << " "
+             << x._is_valid << " "
+             << x._counter;
       return output_stream;
+      return output;
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_reg_free           ,
                           uint32_t   nb_bank               ,
+                          uint32_t   size_counter          )
+                          uint32_t   size_counter          ,
+                          bool       is_toplevel)
+  {
     log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
 …
     _size_counter           = size_counter       ;
-    _size_general_register  = log2(nb_general_register);
-    _size_special_register  = log2(nb_special_register);
     _max_reader             = 1<<size_counter;
 …
     test();
+    if (is_toplevel)
+      {
+        _size_general_register  = log2(nb_general_register);
+        _size_special_register  = log2(nb_special_register);
+        copy ();
+      }
     log_printf(FUNC,Stat_List_unit,FUNCTION,"End");
   };
 …
 #undef  FUNCTION
 #define FUNCTION "Stat_List_unit::~Parameters"
   Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
     log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
     log_printf(FUNC,Stat_List_unit,FUNCTION,"End");
   };
+#undef  FUNCTION
+#define FUNCTION "Stat_List_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
+    log_printf(FUNC,Stat_List_unit,FUNCTION,"End");
+  };
 }; // end namespace stat_list_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit.cpp

-              r81
+              r88
 namespace register_translation_unit {
 namespace stat_list_unit {
 #undef  FUNCTION
 …
     log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
+#if DEBUG_Stat_List_unit == true
+    log_printf(INFO,Stat_List_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Stat_List_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Stat_List_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         // Constant
 …
         SC_METHOD (genMoore);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
 # ifdef SYSTEMCASS_SPECIFIC
 …
         SC_METHOD (genMealy);
         dont_initialize ();
         sensitive << (*(in_CLOCK)).neg();
+        sensitive << (*(in_CLOCK)).neg(); // need internal register
         for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
           sensitive << (*(in_INSERT_READ_RA        [i]))
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Stat_List_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_allocation.cpp

-              r81
+              r88
        ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RC_PHY    ,"num_reg_rc_phy"    ,Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_IN ( in_RETIRE_WRITE_RD          ,"write_rd"          ,Tcontrol_t        ,1                             );
+       ALLOC1_SIGNAL_IN ( in_RETIRE_RESTORE_RD_PHY_OLD,"restore_rd_phy_old",Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RD_PHY_OLD,"num_reg_rd_phy_old",Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RD_PHY_NEW,"num_reg_rd_phy_new",Tgeneral_address_t,_param->_size_general_register);
        ALLOC1_SIGNAL_IN ( in_RETIRE_WRITE_RE          ,"write_re"          ,Tcontrol_t        ,1                             );
+       ALLOC1_SIGNAL_IN ( in_RETIRE_RESTORE_RE_PHY_OLD,"restore_re_phy_old",Tcontrol_t        ,1                             );
        ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RE_PHY_OLD,"num_reg_re_phy_old",Tspecial_address_t,_param->_size_special_register);
        ALLOC1_SIGNAL_IN ( in_RETIRE_NUM_REG_RE_PHY_NEW,"num_reg_re_phy_new",Tspecial_address_t,_param->_size_special_register);
 …
+     }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
      gpr_stat_list = new stat_list_entry_t * [_param->_nb_bank];
      spr_stat_list = new stat_list_entry_t * [_param->_nb_bank];
 …
      internal_PUSH_SPR_VAL      = new Tcontrol_t [_param->_nb_reg_free];
      internal_PUSH_SPR_NUM_BANK = new uint32_t   [_param->_nb_reg_free];
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK ;
 …
         delete []  in_RETIRE_NUM_REG_RC_PHY    ;
         delete []  in_RETIRE_WRITE_RD          ;
+        delete []  in_RETIRE_RESTORE_RD_PHY_OLD;
         delete []  in_RETIRE_NUM_REG_RD_PHY_OLD;
         delete []  in_RETIRE_NUM_REG_RD_PHY_NEW;
         delete []  in_RETIRE_WRITE_RE          ;
+        delete []  in_RETIRE_RESTORE_RE_PHY_OLD;
         delete []  in_RETIRE_NUM_REG_RE_PHY_OLD;
         delete []  in_RETIRE_NUM_REG_RE_PHY_NEW;
 …
         delete []  in_PUSH_SPR_ACK             ;
         delete [] out_PUSH_SPR_NUM_REG         ;
+        // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete [] gpr_stat_list;
+        delete [] spr_stat_list;
+        delete [] internal_INSERT_ACK       ;
+        delete [] internal_RETIRE_ACK       ;
+        delete [] internal_PUSH_GPR_VAL     ;
+        delete [] internal_PUSH_GPR_NUM_BANK;
+        delete [] internal_PUSH_SPR_VAL     ;
+        delete [] internal_PUSH_SPR_NUM_BANK;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    delete [] gpr_stat_list;
-    delete [] spr_stat_list;
-    delete [] internal_INSERT_ACK       ;
-    delete [] internal_RETIRE_ACK       ;
-    delete [] internal_PUSH_GPR_VAL     ;
-    delete [] internal_PUSH_GPR_NUM_BANK;
-    delete [] internal_PUSH_SPR_VAL     ;
-    delete [] internal_PUSH_SPR_NUM_BANK;
     delete _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_genMealy.cpp

-              r81
+              r88
   void Stat_List_unit::genMealy (void)
+  {
+    log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
+    log_begin(Stat_List_unit,FUNCTION);
+    log_function(Stat_List_unit,FUNCTION,_name.c_str());
     for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
 …
+      }
     log_printf(FUNC,Stat_List_unit,FUNCTION,"End");
+    log_end(Stat_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_genMoore.cpp

-              r81
+              r88
   void Stat_List_unit::genMoore (void)
+  {
+    log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
+    log_begin(Stat_List_unit,FUNCTION);
+    log_function(Stat_List_unit,FUNCTION,_name.c_str());
     uint32_t gpr_ptr = internal_GPR_PTR_FREE;
 …
+      }
     log_printf(FUNC,Stat_List_unit,FUNCTION,"End");
+    log_end(Stat_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/src/Stat_List_unit_transition.cpp

-              r81
+              r88
   void Stat_List_unit::transition (void)
+  {
+    log_printf(FUNC,Stat_List_unit,FUNCTION,"Begin");
+    log_begin(Stat_List_unit,FUNCTION);
+    log_function(Stat_List_unit,FUNCTION,_name.c_str());
     if (PORT_READ(in_NRESET) == 0)
 …
               if (PORT_READ(in_RETIRE_WRITE_RD [i]))
+                {
+                  Tcontrol_t restore_old = PORT_READ(in_RETIRE_RESTORE_RD_PHY_OLD [i]);
+                  {
                     Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RD_PHY_OLD [i]);
                     uint32_t bank = num_reg >> _param->_shift_gpr;
                     uint32_t reg  = num_reg  & _param->_mask_gpr ;
                     gpr_stat_list [bank][reg].retire_write_old();
+                    gpr_stat_list [bank][reg].retire_write_old(restore_old);
+                  }
+                  {
 …
                     uint32_t bank = num_reg >> _param->_shift_gpr;
                     uint32_t reg  = num_reg  & _param->_mask_gpr ;
                     gpr_stat_list [bank][reg].retire_write_new();
+                    gpr_stat_list [bank][reg].retire_write_new(restore_old);
+                  }
+                }
 …
               if (PORT_READ(in_RETIRE_WRITE_RE [i]))
+                {
+                  Tcontrol_t restore_old = PORT_READ(in_RETIRE_RESTORE_RE_PHY_OLD [i]);
+                  {
                     Tgeneral_address_t num_reg = PORT_READ(in_RETIRE_NUM_REG_RE_PHY_OLD [i]);
                     uint32_t bank = num_reg >> _param->_shift_spr;
                     uint32_t reg  = num_reg  & _param->_mask_spr ;
                     spr_stat_list [bank][reg].retire_write_old();
+                    spr_stat_list [bank][reg].retire_write_old(restore_old);
+                  }
+                  {
 …
                     uint32_t bank = num_reg >> _param->_shift_spr;
                     uint32_t reg  = num_reg  & _param->_mask_spr ;
                     spr_stat_list [bank][reg].retire_write_new();
+                    spr_stat_list [bank][reg].retire_write_new(restore_old);
+                  }
+                }
 …
         internal_SPR_PTR_FREE = ((internal_SPR_PTR_FREE==0)?_param->_nb_special_register_by_bank:internal_SPR_PTR_FREE)-1;
+      }
+//     log_printf(TRACE,Stat_List_unit,FUNCTION,"Print gpr_stat_list :");
+//     for (uint32_t i=0; i<_param->_nb_bank; i++)
+//       {
+//      log_printf(TRACE,Stat_List_unit,FUNCTION," * Bank : %d",i);
+//      for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
+//        {
+//          std::ostringstream str;
+//          str << gpr_stat_list [i][j];
+//          log_printf(TRACE,Stat_List_unit,FUNCTION,"   [%d] %s",j,str.str().c_str());
+//        }
+//       }
+//     log_printf(TRACE,Stat_List_unit,FUNCTION,"Print spr_stat_list :");
+//     for (uint32_t i=0; i<_param->_nb_bank; i++)
+//       {
+//      log_printf(TRACE,Stat_List_unit,FUNCTION," * Bank : %d",i);
+//      for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
+//        {
+//          std::ostringstream str;
+//          str << spr_stat_list [i][j];
+//          log_printf(TRACE,Stat_List_unit,FUNCTION,"   [%d] %s",j,str.str().c_str());
+//        }
+//       }
+#if (DEBUG >= DEBUG_TRACE)
+    log_printf(TRACE,Stat_List_unit,FUNCTION,"  * Dump Stat List");
+    for (uint32_t i=0; i<_param->_nb_bank; i++)
+      for (uint32_t j=0; j<_param->_nb_general_register_by_bank; j++)
+        log_printf(TRACE,Stat_List_unit,FUNCTION,"    * GPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d, valid %.1d, counter %.4d",
+                   i,
+                   j,
+                   (i<<_param->_shift_gpr)|j,
+                   gpr_stat_list[i][j]._is_free,
+                   gpr_stat_list[i][j]._is_link,
+                   gpr_stat_list[i][j]._is_valid,
+                   gpr_stat_list[i][j]._counter);
+    for (uint32_t i=0; i<_param->_nb_bank; i++)
+      for (uint32_t j=0; j<_param->_nb_special_register_by_bank; j++)
+        log_printf(TRACE,Stat_List_unit,FUNCTION,"    * SPR[%.4d][%.5d] (%.5d) - free %.1d, link %.1d, valid %.1d, counter %.4d",
+                   i,
+                   j,
+                   (i<<_param->_shift_spr)|j,
+                   spr_stat_list[i][j]._is_free,
+                   spr_stat_list[i][j]._is_link,
+                   spr_stat_list[i][j]._is_valid,
+                   spr_stat_list[i][j]._counter);
+#endif
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
 …
 #endif
     log_printf(FUNC,Stat_List_unit,FUNCTION,"End");
+    log_end(Stat_List_unit,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/include/Parameters.h

-              r82
+              r88
   public : uint32_t   _size_read_counter     ;
   public : uint32_t   _size_front_end_id     ;
   public : uint32_t   _size_context_id       ;
   public : uint32_t   _size_general_register ;
   public : uint32_t   _size_special_register ;
+//public : uint32_t   _size_front_end_id     ;
+//public : uint32_t   _size_context_id       ;
+//public : uint32_t   _size_general_register ;
+//public : uint32_t   _size_special_register ;
   public : uint32_t   _have_port_context_id  ;
   public : uint32_t   _have_port_front_end_id;
+//public : uint32_t   _have_port_context_id  ;
+//public : uint32_t   _have_port_front_end_id;
   public : morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::dependency_checking_unit::         Parameters * _param_dependency_checking_unit;
 …
                         uint32_t   nb_reg_free           ,
                         uint32_t   nb_bank               ,
+                        uint32_t   size_read_counter     );
+                        uint32_t   size_read_counter     ,
+                        bool       is_toplevel=false);
 //   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Parameters.cpp

-              r81
+              r88
                           uint32_t   nb_reg_free           ,
                           uint32_t   nb_bank               ,
+                          uint32_t   size_read_counter     )
+                          uint32_t   size_read_counter     ,
+                          bool       is_toplevel)
+  {
     log_printf(FUNC,Register_translation_unit,FUNCTION,"Begin");
 …
     _size_read_counter   = size_read_counter  ;
+    uint32_t max_nb_context = max<uint32_t>(nb_context, nb_front_end);
+    uint32_t size_general_register = log2(nb_general_register);
+    uint32_t size_special_register = log2(nb_special_register);
+    uint32_t max_nb_context        = max<uint32_t>(nb_context, nb_front_end);
-    _size_front_end_id      = log2(nb_front_end       );
-    _size_context_id        = log2(max_nb_context     );
-    _size_general_register  = log2(nb_general_register);
-    _size_special_register  = log2(nb_special_register);
-    _have_port_front_end_id = _size_front_end_id>0;
-    _have_port_context_id   = _size_context_id  >0;
     uint32_t nb_thread = 0;
     for (uint32_t i=0; i<nb_front_end; i++)
 …
     _param_register_translation_unit_glue    = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::register_translation_unit_glue::Parameters
       (_nb_inst_insert,
+       _nb_inst_retire);
+       _nb_inst_retire,
+        size_general_register,
+        size_special_register);
     test();
+    if (is_toplevel)
+      {
+        _size_front_end_id      = log2(nb_front_end       );
+        _size_context_id        = log2(max_nb_context     );
+        _size_general_register  = size_general_register;
+        _size_special_register  = size_special_register;
+        _have_port_front_end_id = _size_front_end_id>0;
+        _have_port_context_id   = _size_context_id  >0;
+        copy();
+      }
     log_printf(FUNC,Register_translation_unit,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Register_translation_unit::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Register_translation_unit,FUNCTION,"Begin");
+    COPY(_param_dependency_checking_unit);
+    COPY(_param_free_list_unit);
+    COPY(_param_register_address_translation_unit);
+    COPY(_param_stat_list_unit);
+    COPY(_param_register_translation_unit_glue);
+    log_printf(FUNC,Register_translation_unit,FUNCTION,"End");
+  };
 }; // end namespace register_translation_unit
 }; // end namespace rename_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Register_translation_unit.cpp

-              r81
+              r88
     log_printf(FUNC,Register_translation_unit,FUNCTION,"Begin");
+#if DEBUG_Register_translation_unit == true
+    log_printf(INFO,Register_translation_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Register_translation_unit,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Register_translation_unit,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Register_translation_unit,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Register_translation_unit,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Register_translation_unit_allocation.cpp

-              r82
+              r88
+     {
        name = _name+"_dependency_checking_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_dependency_checking_unit = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::dependency_checking_unit::Dependency_checking_unit
          (name.c_str()
 …
+     {
        name = _name+"_free_list_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_free_list_unit = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::free_list_unit::Free_List_unit
 …
+     {
        name = _name+"_register_address_translation_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_register_address_translation_unit = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::register_address_translation_unit::Register_Address_Translation_unit
 …
+     {
        name = _name+"_stat_list_unit";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_stat_list_unit = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::stat_list_unit::Stat_List_unit
 …
+     {
        name = _name+"_register_translation_unit_glue";
        std::cout << "Create   : " << name << std::endl;
+       log_printf(INFO,Core,FUNCTION,_("Create   : %s"),name.c_str());
        _component_register_translation_unit_glue = new morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::register_translation_unit_glue::Register_translation_unit_Glue
 …
     // ~~~~~[ Instanciation ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     std::string src,dest;
+    // ===================================================================
+    // =====[ register_address_translation_unit ]=========================
+    // ===================================================================
+    {
+      src = _name+"_register_address_translation_unit";
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
+        dest = _name;
+#ifdef POSITION
+        _component->interface_map (src ,"",
+                                   dest,"");
+#endif
+        PORT_MAP(_component,src , "in_CLOCK" ,dest, "in_CLOCK");
+        PORT_MAP(_component,src , "in_NRESET",dest, "in_NRESET");
+      }
+      // ~~~~~[ Interface "rename" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
+          dest = _name;
+#ifdef POSITION
+          _component->interface_map (src ,"rename_"+toString(i)
+                                     dest,"rename_"+toString(i));
+#endif
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_VAL"               ,
+                              dest, "in_RENAME_"+toString(i)+"_VAL"               );
+          if (_param->_have_port_front_end_id)
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_FRONT_END_ID"      ,
+                              dest, "in_RENAME_"+toString(i)+"_FRONT_END_ID"      );
+          if (_param->_have_port_context_id)
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_CONTEXT_ID"        ,
+                              dest, "in_RENAME_"+toString(i)+"_CONTEXT_ID"        );
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RA_LOG"    ,
+                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RA_LOG"    );
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RB_LOG"    ,
+                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RB_LOG"    );
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RC_LOG"    ,
+                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RC_LOG"    );
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RD_LOG"    ,
+                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RD_LOG"    );
+          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RE_LOG"    ,
+                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RE_LOG"    );
+          dest = _name+"_register_translation_unit_glue";
+          COMPONENT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_ACK",
+                                   dest, "in_INSERT_"+toString(i)+"_RAT_RENAME_ACK");
+          dest = _name+"_dependency_checking_unit";
+          COMPONENT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RA_PHY"    ,
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RA_PHY"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RB_PHY"    ,
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RB_PHY"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RC_PHY"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
+          COMPONENT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
+        }
+      // ~~~~~[ Interface "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
+          dest = _name+"_register_translation_unit_glue";
+#ifdef POSITION
+          _component->interface_map (src ,"rename_"+toString(i)
+                                     dest,"rename_in_"+toString(i));
+#endif
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_VAL",
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_INSERT_VAL");
+          COMPONENT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_ACK",
+                                   dest, "in_INSERT_"+toString(i)+"_RAT_INSERT_ACK");
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RD"      ,
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_WRITE_RD"      );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RE"      ,
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_WRITE_RE"      );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RD_LOG",
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_NUM_REG_RD_LOG");
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RE_LOG",
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_NUM_REG_RE_LOG");
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RD_PHY",
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_NUM_REG_RD_PHY_NEW");
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RE_PHY",
+                                   dest,"out_INSERT_"+toString(i)+"_RAT_NUM_REG_RE_PHY_NEW");
+        }
+      // ~~~~~[ Interface "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+        {
+          dest = _name;
+#ifdef POSITION
+          _component->interface_map (src ,"retire_"+toString(i)
+                                     dest,"retire_"+toString(i));
+#endif
+          if (_param->_have_port_front_end_id)
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_FRONT_END_ID"      ,
+                              dest, "in_RETIRE_"+toString(i)+"_FRONT_END_ID"      );
+          if (_param->_have_port_context_id)
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_CONTEXT_ID"        ,
+                              dest, "in_RETIRE_"+toString(i)+"_CONTEXT_ID"        );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_EVENT_STATE"       ,
+                              dest, "in_RETIRE_"+toString(i)+"_EVENT_STATE"       );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_WRITE_RD"          ,
+                              dest, "in_RETIRE_"+toString(i)+"_WRITE_RD"          );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_WRITE_RE"          ,
+                              dest, "in_RETIRE_"+toString(i)+"_WRITE_RE"          );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RD_LOG"    ,
+                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RD_LOG"    );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RE_LOG"    ,
+                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RE_LOG"    );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
+                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
+                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
+          dest = _name+"_register_translation_unit_glue";
+          COMPONENT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_VAL"          ,
+                                   dest,"out_RETIRE_"+toString(i)+"_RAT_VAL"      );
+          COMPONENT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_ACK"          ,
+                                   dest, "in_RETIRE_"+toString(i)+"_RAT_ACK"      );
+          dest = _name+"_stat_list_unit";
+          COMPONENT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_RESTORE_RD_PHY_OLD",
+                                   dest, "in_RETIRE_"+toString(i)+"_RESTORE_RD_PHY_OLD");
+          COMPONENT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_RESTORE_RE_PHY_OLD",
+                                   dest, "in_RETIRE_"+toString(i)+"_RESTORE_RE_PHY_OLD");
+        }
+    }
+    // ===================================================================
+    // =====[ free_list_unit ]============================================
+    // ===================================================================
+    {
+      src = _name+"_free_list_unit";
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
+        dest = _name;
+#ifdef POSITION
+        _component->interface_map (src ,"",
+                                   dest,"");
+#endif
+        PORT_MAP(_component,src , "in_CLOCK" ,dest, "in_CLOCK");
+        PORT_MAP(_component,src , "in_NRESET",dest, "in_NRESET");
+      }
+      // ~~~~~[ interface : "pop" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
+          dest = _name;
+#ifdef POSITION
+          _component->interface_map (src ,"pop_"+toString(i)
+                                     dest,"rename_"+toString(i));
+#endif
+          PORT_MAP(_component,src , "in_POP_"+toString(i)+"_GPR_VAL"    ,
+                              dest,"in_RENAME_"+toString(i)+"_WRITE_RD");
+          PORT_MAP(_component,src , "in_POP_"+toString(i)+"_SPR_VAL"    ,
+                              dest,"in_RENAME_"+toString(i)+"_WRITE_RE");
+          dest = _name+"_register_translation_unit_glue";
+          COMPONENT_MAP(_component,src , "in_POP_"+toString(i)+"_VAL" ,
+                                   dest,"out_INSERT_"+toString(i)+"_FREE_LIST_VAL" );
+          COMPONENT_MAP(_component,src ,"out_POP_"+toString(i)+"_ACK" ,
+                                   dest, "in_INSERT_"+toString(i)+"_FREE_LIST_ACK" );
+          dest = _name+"_dependency_checking_unit";
+          COMPONENT_MAP(_component,src ,"out_POP_"+toString(i)+"_GPR_NUM_REG",
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RD_PHY_NEW");
+          COMPONENT_MAP(_component,src ,"out_POP_"+toString(i)+"_SPR_NUM_REG",
+                                   dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_PHY_NEW");
+        }
+      // ~~~~~[ interface : "push_gpr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      // ~~~~~[ interface : "push_spr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      for (uint32_t i=0; i<_param->_nb_reg_free; i++)
+        {
+          dest = _name+"_stat_list_unit";
+#ifdef POSITION
+          _component->interface_map (src ,"push_gpr_"+toString(i)
+                                     dest,"push_gpr_"+toString(i));
+#endif
+          COMPONENT_MAP(_component,src , "in_PUSH_GPR_"+toString(i)+"_VAL"    ,
+                                   dest,"out_PUSH_GPR_"+toString(i)+"_VAL"    );
+          COMPONENT_MAP(_component,src ,"out_PUSH_GPR_"+toString(i)+"_ACK"    ,
+                                   dest, "in_PUSH_GPR_"+toString(i)+"_ACK"    );
+          COMPONENT_MAP(_component,src , "in_PUSH_GPR_"+toString(i)+"_NUM_REG",
+                                   dest,"out_PUSH_GPR_"+toString(i)+"_NUM_REG");
+#ifdef POSITION
+          _component->interface_map (src ,"push_spr_"+toString(i)
+                                     dest,"push_spr_"+toString(i));
+#endif
+          COMPONENT_MAP(_component,src , "in_PUSH_SPR_"+toString(i)+"_VAL"    ,
+                                   dest,"out_PUSH_SPR_"+toString(i)+"_VAL"    );
+          COMPONENT_MAP(_component,src ,"out_PUSH_SPR_"+toString(i)+"_ACK"    ,
+                                   dest, "in_PUSH_SPR_"+toString(i)+"_ACK"    );
+          COMPONENT_MAP(_component,src , "in_PUSH_SPR_"+toString(i)+"_NUM_REG",
+                                   dest,"out_PUSH_SPR_"+toString(i)+"_NUM_REG");
+        }
+    }
     // ===================================================================
     // =====[ dependency_checking_unit ]==================================
 …
+    {
       src = _name+"_dependency_checking_unit";
       std::cout << "Instance : " << src << std::endl;
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
 …
 #endif
 //        PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_VAL"               ,dest,);
 //        PORT_MAP(_component,src ,"out_RENAME_IN_"+toString(i)+"_ACK"               ,dest,);
+// //     PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_VAL"               ,dest,);
+// //     PORT_MAP(_component,src ,"out_RENAME_IN_"+toString(i)+"_ACK"               ,dest,);
           if (_param->_have_port_front_end_id)
           PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_FRONT_END_ID"      ,
 …
           PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_LOG"    ,
                               dest, "in_RENAME_"+toString(i)+"_NUM_REG_RE_LOG"    );
-          dest = _name+"_register_address_translation_unit";
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RA_PHY"    ,
+                              dest,"out_RENAME_"+toString(i)+"_NUM_REG_RA_PHY"    );
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RB_PHY"    ,
+                              dest,"out_RENAME_"+toString(i)+"_NUM_REG_RB_PHY"    );
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                              dest,"out_RENAME_"+toString(i)+"_NUM_REG_RC_PHY"    );
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
+                              dest,"out_RENAME_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
+                              dest,"out_RENAME_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
+          // in_RENAME_IN_NUM_REG_RA_PHY     - register_address_translation_unit
+          // in_RENAME_IN_NUM_REG_RB_PHY     - register_address_translation_unit
+          // in_RENAME_IN_NUM_REG_RC_PHY     - register_address_translation_unit
+          // in_RENAME_IN_NUM_REG_RD_PHY_OLD - register_address_translation_unit
+          // in_RENAME_IN_NUM_REG_RE_PHY_OLD - register_address_translation_unit
+          dest = _name+"_free_list_unit";
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RD_PHY_NEW",
+                              dest,"out_POP_"+toString(i)+"_GPR_NUM_REG");
+          PORT_MAP(_component,src , "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_PHY_NEW",
+                              dest,"out_POP_"+toString(i)+"_SPR_NUM_REG");
+          // in_RENAME_IN_NUM_REG_RD_PHY_NEW - free_list_unit
+          // in_RENAME_IN_NUM_REG_RE_PHY_NEW - free_list_unit
+        }
 …
 #endif
-//        PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_VAL"               ,
-//                            dest,"out_INSERT_"+toString(i)+"_VAL"               );
-//        PORT_MAP(_component,src , "in_RENAME_OUT_"+toString(i)+"_ACK"               ,
-//                            dest, "in_INSERT_"+toString(i)+"_ACK"               );
           if (_param->_have_port_front_end_id)
           PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_FRONT_END_ID"      ,
 …
           PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_CONTEXT_ID"        ,
                               dest,"out_INSERT_"+toString(i)+"_CONTEXT_ID"        );
-          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_READ_RA"           ,
-                              dest,"out_INSERT_"+toString(i)+"_READ_RA"           );
           PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RA_LOG"    ,
                               dest,"out_INSERT_"+toString(i)+"_NUM_REG_RA_LOG"    );
-          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RA_PHY"    ,
-                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RA_PHY"    );
-          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_READ_RB"           ,
-                              dest,"out_INSERT_"+toString(i)+"_READ_RB"           );
           PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RB_LOG"    ,
                               dest,"out_INSERT_"+toString(i)+"_NUM_REG_RB_LOG"    );
-          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RB_PHY"    ,
-                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RB_PHY"    );
-          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_READ_RC"           ,
-                              dest,"out_INSERT_"+toString(i)+"_READ_RC"           );
           PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RC_LOG"    ,
                               dest,"out_INSERT_"+toString(i)+"_NUM_REG_RC_LOG"    );
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RC_PHY"    );
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_WRITE_RD"          ,
+                              dest,"out_INSERT_"+toString(i)+"_WRITE_RD"          );
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_LOG"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RD_LOG"    );
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_PHY_NEW",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_NEW");
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_WRITE_RE"          ,
+                              dest,"out_INSERT_"+toString(i)+"_WRITE_RE"          );
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_LOG"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RE_LOG"    );
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
+          PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_PHY_NEW",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_NEW");
+        }
+//        PORT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_VAL"               ,
+//                            dest,"out_INSERT_"+toString(i)+"_VAL"               );
+//        PORT_MAP(_component,src , "in_RENAME_OUT_"+toString(i)+"_ACK"               ,
+//                            dest, "in_INSERT_"+toString(i)+"_ACK"               );
+          dest = _name+"_register_translation_unit_glue";
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_READ_RA"           ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_READ_RA"           );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RA_PHY"    ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RA_PHY"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_READ_RB"           ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_READ_RB"           );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RB_PHY"    ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RB_PHY"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_READ_RC"           ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_READ_RC"           );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RC_PHY"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_WRITE_RD"          ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_WRITE_RD"          );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_LOG"    ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RD_LOG"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD");
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_PHY_NEW",
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW");
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_WRITE_RE"          ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_WRITE_RE"          );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_LOG"    ,
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RE_LOG"    );
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD");
+          COMPONENT_MAP(_component,src ,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_PHY_NEW",
+                                   dest, "in_INSERT_"+toString(i)+"_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW");
+        }
+    }
     // ===================================================================
     // =====[ free_list_unit ]============================================
+    // =====[ stat_list_unit ]============================================
     // ===================================================================
+    {
       src = _name+"_free_list_unit";
       std::cout << "Instance : " << src << std::endl;
+      src = _name+"_stat_list_unit";
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
 …
+      }
-      // ~~~~~[ interface : "pop" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-      for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
-          dest = _name;
-#ifdef POSITION
-          _component->interface_map (src ,"pop_"+toString(i)
-                                     dest,"rename_"+toString(i));
-#endif
-          PORT_MAP(_component,src , "in_POP_"+toString(i)+"_GPR_VAL"    ,
-                              dest,"in_RENAME_"+toString(i)+"_WRITE_RD");
-          PORT_MAP(_component,src , "in_POP_"+toString(i)+"_SPR_VAL"    ,
-                              dest,"in_RENAME_"+toString(i)+"_WRITE_RE");
-          dest = _name+"_register_translation_unit_glue";
-          PORT_MAP(_component,src , "in_POP_"+toString(i)+"_VAL" ,
-                              dest,"out_INSERT_"+toString(i)+"_FREE_LIST_VAL" );
-          PORT_MAP(_component,src ,"out_POP_"+toString(i)+"_ACK" ,
-                              dest, "in_INSERT_"+toString(i)+"_FREE_LIST_ACK" );
-          dest = _name+"_dependency_checking_unit";
-          PORT_MAP(_component,src ,"out_POP_"+toString(i)+"_GPR_NUM_REG",
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RD_PHY_NEW");
-          PORT_MAP(_component,src ,"out_POP_"+toString(i)+"_SPR_NUM_REG",
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_PHY_NEW");
+        }
-      // ~~~~~[ interface : "push_gpr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-      // ~~~~~[ interface : "push_spr" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-      for (uint32_t i=0; i<_param->_nb_reg_free; i++)
+        {
-          dest = _name+"_stat_list_unit";
-#ifdef POSITION
-          _component->interface_map (src ,"push_gpr_"+toString(i)
-                                     dest,"push_gpr_"+toString(i));
-#endif
-          PORT_MAP(_component,src , "in_PUSH_GPR_"+toString(i)+"_VAL"    ,
-                              dest,"out_PUSH_GPR_"+toString(i)+"_VAL"    );
-          PORT_MAP(_component,src ,"out_PUSH_GPR_"+toString(i)+"_ACK"    ,
-                              dest, "in_PUSH_GPR_"+toString(i)+"_ACK"    );
-          PORT_MAP(_component,src , "in_PUSH_GPR_"+toString(i)+"_NUM_REG",
-                              dest,"out_PUSH_GPR_"+toString(i)+"_NUM_REG");
-#ifdef POSITION
-          _component->interface_map (src ,"push_spr_"+toString(i)
-                                     dest,"push_spr_"+toString(i));
-#endif
-          PORT_MAP(_component,src , "in_PUSH_SPR_"+toString(i)+"_VAL"    ,
-                              dest,"out_PUSH_SPR_"+toString(i)+"_VAL"    );
-          PORT_MAP(_component,src ,"out_PUSH_SPR_"+toString(i)+"_ACK"    ,
-                              dest, "in_PUSH_SPR_"+toString(i)+"_ACK"    );
-          PORT_MAP(_component,src , "in_PUSH_SPR_"+toString(i)+"_NUM_REG",
-                              dest,"out_PUSH_SPR_"+toString(i)+"_NUM_REG");
+        }
+    }
-    // ===================================================================
-    // =====[ register_address_translation_unit ]=========================
-    // ===================================================================
+    {
-      src = _name+"_register_address_translation_unit";
-      std::cout << "Instance : " << src << std::endl;
+      {
-        dest = _name;
-#ifdef POSITION
-        _component->interface_map (src ,"",
-                                   dest,"");
-#endif
-        PORT_MAP(_component,src , "in_CLOCK" ,dest, "in_CLOCK");
-        PORT_MAP(_component,src , "in_NRESET",dest, "in_NRESET");
+      }
-      // ~~~~~[ Interface "rename" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-      for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
-          dest = _name;
-#ifdef POSITION
-          _component->interface_map (src ,"rename_"+toString(i)
-                                     dest,"rename_"+toString(i));
-#endif
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_VAL"               ,
-                              dest, "in_RENAME_"+toString(i)+"_VAL"               );
-          if (_param->_have_port_front_end_id)
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_FRONT_END_ID"      ,
-                              dest, "in_RENAME_"+toString(i)+"_FRONT_END_ID"      );
-          if (_param->_have_port_context_id)
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_CONTEXT_ID"        ,
-                              dest, "in_RENAME_"+toString(i)+"_CONTEXT_ID"        );
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RA_LOG"    ,
-                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RA_LOG"    );
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RB_LOG"    ,
-                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RB_LOG"    );
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RC_LOG"    ,
-                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RC_LOG"    );
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RD_LOG"    ,
-                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RD_LOG"    );
-          PORT_MAP(_component,src , "in_RENAME_"+toString(i)+"_NUM_REG_RE_LOG"    ,
-                              dest, "in_RENAME_"+toString(i)+"_NUM_REG_RE_LOG"    );
-          dest = _name+"_register_translation_unit_glue";
-          PORT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_ACK",
-                              dest, "in_INSERT_"+toString(i)+"_RAT_RENAME_ACK");
-          dest = _name+"_dependency_checking_unit";
-          PORT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RA_PHY"    ,
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RA_PHY"    );
-          PORT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RB_PHY"    ,
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RB_PHY"    );
-          PORT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RC_PHY"    ,
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RC_PHY"    );
-          PORT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
-          PORT_MAP(_component,src ,"out_RENAME_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
-                              dest, "in_RENAME_IN_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
+        }
       // ~~~~~[ Interface "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
-          dest = _name+"_dependency_checking_unit";
-#ifdef POSITION
-          _component->interface_map (src ,"rename_"+toString(i)
-                                     dest,"rename_in_"+toString(i));
-#endif
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RD"      ,
-                              dest,"out_RENAME_OUT_"+toString(i)+"_WRITE_RD"      );
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RE"      ,
-                              dest,"out_RENAME_OUT_"+toString(i)+"_WRITE_RE"      );
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RD_LOG",
-                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_LOG");
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RE_LOG",
-                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_LOG");
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RD_PHY",
-                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RE_PHY",
-                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
           dest = _name+"_register_translation_unit_glue";
-          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_VAL",
-                              dest,"out_INSERT_"+toString(i)+"_RAT_INSERT_VAL");
-          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_ACK",
-                              dest, "in_INSERT_"+toString(i)+"_RAT_INSERT_ACK");
+        }
-      // ~~~~~[ Interface "retire" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-      for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
+        {
-          dest = _name;
-#ifdef POSITION
-          _component->interface_map (src ,"retire_"+toString(i)
-                                     dest,"retire_"+toString(i));
-#endif
-          if (_param->_have_port_front_end_id)
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_FRONT_END_ID"      ,
-                              dest, "in_RETIRE_"+toString(i)+"_FRONT_END_ID"      );
-          if (_param->_have_port_context_id)
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_CONTEXT_ID"        ,
-                              dest, "in_RETIRE_"+toString(i)+"_CONTEXT_ID"        );
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_EVENT_STATE"       ,
-                              dest, "in_RETIRE_"+toString(i)+"_EVENT_STATE"       );
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_WRITE_RD"          ,
-                              dest, "in_RETIRE_"+toString(i)+"_WRITE_RD"          );
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_WRITE_RE"          ,
-                              dest, "in_RETIRE_"+toString(i)+"_WRITE_RE"          );
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RD_LOG"    ,
-                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RD_LOG"    );
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RE_LOG"    ,
-                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RE_LOG"    );
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
-                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
-                              dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
-          dest = _name+"_register_translation_unit_glue";
-          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_VAL"          ,
-                              dest,"out_RETIRE_"+toString(i)+"_RAT_VAL"      );
-          PORT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_ACK"          ,
-                              dest, "in_RETIRE_"+toString(i)+"_RAT_ACK"      );
+        }
+    }
-    // ===================================================================
-    // =====[ stat_list_unit ]============================================
-    // ===================================================================
+    {
-      src = _name+"_stat_list_unit";
-      std::cout << "Instance : " << src << std::endl;
+      {
-        dest = _name;
-#ifdef POSITION
-        _component->interface_map (src ,"",
-                                   dest,"");
-#endif
-        PORT_MAP(_component,src , "in_CLOCK" ,dest, "in_CLOCK");
-        PORT_MAP(_component,src , "in_NRESET",dest, "in_NRESET");
+      }
-      // ~~~~~[ Interface "insert" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-      for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
+        {
-          dest = _name+"_dependency_checking_unit";
 #ifdef POSITION
           _component->interface_map (src ,"insert_"+toString(i)
+                                     dest,"rename_out_"+toString(i));
+#endif
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_READ_RA"           ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_READ_RA"           );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RA_PHY"    ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RA_PHY"    );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_READ_RB"           ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_READ_RB"           );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RB_PHY"    ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RB_PHY"    );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_READ_RC"           ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_READ_RC"           );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RC_PHY"    );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RD"          ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_WRITE_RD"          );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_NEW",
+                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RD_PHY_NEW");
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RE"          ,
+                              dest,"out_RENAME_OUT_"+toString(i)+"_WRITE_RE"          );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_NEW",
+                              dest,"out_RENAME_OUT_"+toString(i)+"_NUM_REG_RE_PHY_NEW");
+          dest = _name+"_register_translation_unit_glue";
+          PORT_MAP(_component,src ,  "in_INSERT_"+toString(i)+"_VAL" ,
+                              dest,"out_INSERT_"+toString(i)+"_STAT_LIST_VAL");
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_ACK" ,
+                              dest, "in_INSERT_"+toString(i)+"_STAT_LIST_ACK" );
+                                     dest,"insert_stat_list_"+toString(i));
+#endif
+          COMPONENT_MAP(_component,src ,  "in_INSERT_"+toString(i)+"_VAL" ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_VAL");
+          COMPONENT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_ACK" ,
+                                   dest, "in_INSERT_"+toString(i)+"_STAT_LIST_ACK" );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_READ_RA"           ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_READ_RA"           );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RA_PHY"    ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_NUM_REG_RA_PHY"    );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_READ_RB"           ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_READ_RB"           );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RB_PHY"    ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_NUM_REG_RB_PHY"    );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_READ_RC"           ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_READ_RC"           );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_NUM_REG_RC_PHY"    );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RD"          ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_WRITE_RD"          );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_NEW",
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_NUM_REG_RD_PHY_NEW");
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_WRITE_RE"          ,
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_WRITE_RE"          );
+          COMPONENT_MAP(_component,src , "in_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_NEW",
+                                   dest,"out_INSERT_"+toString(i)+"_STAT_LIST_NUM_REG_RE_PHY_NEW");
+        }
 …
                               dest, "in_RETIRE_"+toString(i)+"_NUM_REG_RE_PHY_NEW");
+          // in_RETIRE_RESTORE_RD_PHY_OLD - register_address_translation_unit.out_RETIRE_RESTORE_RD_PHY_OLD
+          // in_RETIRE_RESTORE_RE_PHY_OLD - register_address_translation_unit.out_RETIRE_RESTORE_RE_PHY_OLD
           dest = _name+"_register_translation_unit_glue";
           PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_VAL",
                               dest,"out_RETIRE_"+toString(i)+"_STAT_LIST_VAL");
           PORT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_ACK",
                               dest, "in_RETIRE_"+toString(i)+"_STAT_LIST_ACK");
+          COMPONENT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_VAL",
+                                   dest,"out_RETIRE_"+toString(i)+"_STAT_LIST_VAL");
+          COMPONENT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_ACK",
+                                   dest, "in_RETIRE_"+toString(i)+"_STAT_LIST_ACK");
+        }
 …
 #endif
+          PORT_MAP(_component,src ,"out_PUSH_GPR_"+toString(i)+"_VAL"    ,
+                              dest, "in_PUSH_GPR_"+toString(i)+"_VAL"    );
+          PORT_MAP(_component,src , "in_PUSH_GPR_"+toString(i)+"_ACK"    ,
+                              dest,"out_PUSH_GPR_"+toString(i)+"_ACK"    );
+          PORT_MAP(_component,src ,"out_PUSH_GPR_"+toString(i)+"_NUM_REG",
+                              dest, "in_PUSH_GPR_"+toString(i)+"_NUM_REG");
+          //out_PUSH_GPR_VAL     - free_list_unit
+          // in_PUSH_GPR_ACK     - free_list_unit
+          //out_PUSH_GPR_NUM_REG - free_list_unit
 #ifdef POSITION
 …
 #endif
+          PORT_MAP(_component,src ,"out_PUSH_SPR_"+toString(i)+"_VAL"    ,
+                              dest, "in_PUSH_SPR_"+toString(i)+"_VAL"    );
+          PORT_MAP(_component,src , "in_PUSH_SPR_"+toString(i)+"_ACK"    ,
+                              dest,"out_PUSH_SPR_"+toString(i)+"_ACK"    );
+          PORT_MAP(_component,src ,"out_PUSH_SPR_"+toString(i)+"_NUM_REG",
+                              dest, "in_PUSH_SPR_"+toString(i)+"_NUM_REG");
+          //out_PUSH_SPR_VAL     - free_list_unit
+          // in_PUSH_SPR_ACK     - free_list_unit
+          //out_PUSH_SPR_NUM_REG - free_list_unit
+        }
+    }
 …
+    {
       src = _name+"_register_translation_unit_glue";
       std::cout << "Instance : " << src << std::endl;
+      log_printf(INFO,Core,FUNCTION,_("Instance : %s"),src.c_str());
+      {
 …
                               dest, "in_INSERT_"+toString(i)+"_ACK"    );
+          dest = _name+"_register_address_translation_unit";
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_RAT_INSERT_VAL",
+                              dest, "in_INSERT_"+toString(i)+"_VAL");
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_RAT_RENAME_ACK",
+                              dest,"out_RENAME_"+toString(i)+"_ACK");
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_RAT_INSERT_ACK",
+                              dest,"out_INSERT_"+toString(i)+"_ACK");
+          dest = _name+"_free_list_unit";
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_FREE_LIST_VAL" ,
+                              dest, "in_POP_"+toString(i)+"_VAL" );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_FREE_LIST_ACK" ,
+                              dest,"out_POP_"+toString(i)+"_ACK" );
+          dest = _name+"_stat_list_unit";
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_STAT_LIST_VAL" ,
+                              dest, "in_INSERT_"+toString(i)+"_VAL" );
+          PORT_MAP(_component,src , "in_INSERT_"+toString(i)+"_STAT_LIST_ACK" ,
+                              dest,"out_INSERT_"+toString(i)+"_ACK" );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_READ_RA"           ,
+                              dest,"out_INSERT_"+toString(i)+"_READ_RA"           );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RA_PHY"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RA_PHY"    );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_READ_RB"           ,
+                              dest,"out_INSERT_"+toString(i)+"_READ_RB"           );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RB_PHY"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RB_PHY"    );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_READ_RC"           ,
+                              dest,"out_INSERT_"+toString(i)+"_READ_RC"           );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RC_PHY"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RC_PHY"    );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_WRITE_RD"          ,
+                              dest,"out_INSERT_"+toString(i)+"_WRITE_RD"          );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RD_LOG"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RD_LOG"    );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_OLD",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_OLD");
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_NEW",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RD_PHY_NEW");
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_WRITE_RE"          ,
+                              dest,"out_INSERT_"+toString(i)+"_WRITE_RE"          );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RE_LOG"    ,
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RE_LOG"    );
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_OLD",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_OLD");
+          PORT_MAP(_component,src ,"out_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_NEW",
+                              dest,"out_INSERT_"+toString(i)+"_NUM_REG_RE_PHY_NEW");
+          // out_INSERT_RAT_INSERT_VAL - register_address_translation_unit
+          //  in_INSERT_RAT_RENAME_ACK - register_address_translation_unit
+          //  in_INSERT_RAT_INSERT_ACK - register_address_translation_unit
+          // out_INSERT_FREE_LIST_VAL  - free_list_unit
+          //  in_INSERT_FREE_LIST_ACK  - free_list_unit
+          // out_INSERT_STAT_LIST_VAL  - stat_list_unit
+          //  in_INSERT_STAT_LIST_ACK  - stat_list_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_READ_RA            - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RA_PHY     - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_READ_RB            - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RB_PHY     - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_READ_RC            - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RC_PHY     - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_WRITE_RD           - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_LOG     - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_OLD - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RD_PHY_NEW - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_WRITE_RE           - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_LOG     - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_OLD - dependency_checking_unit
+          //  in_INSERT_DEPENDENCY_CHECKING_NUM_REG_RE_PHY_NEW - dependency_checking_unit
+          // out_INSERT_STAT_LIST_READ_RA                      - stat_list_unit
+          // out_INSERT_STAT_LIST_NUM_REG_RA_PHY               - stat_list_unit
+          // out_INSERT_STAT_LIST_READ_RB                      - stat_list_unit
+          // out_INSERT_STAT_LIST_NUM_REG_RB_PHY               - stat_list_unit
+          // out_INSERT_STAT_LIST_READ_RC                      - stat_list_unit
+          // out_INSERT_STAT_LIST_NUM_REG_RC_PHY               - stat_list_unit
+          // out_INSERT_STAT_LIST_WRITE_RD                     - stat_list_unit
+          // out_INSERT_STAT_LIST_NUM_REG_RD_PHY_NEW           - stat_list_unit
+          // out_INSERT_STAT_LIST_WRITE_RE                     - stat_list_unit
+          // out_INSERT_STAT_LIST_NUM_REG_RE_PHY_NEW           - stat_list_unit
+          // out_INSERT_RAT_WRITE_RD                           - register_address_translation_unit
+          // out_INSERT_RAT_NUM_REG_RD_LOG                     - register_address_translation_unit
+          // out_INSERT_RAT_NUM_REG_RD_PHY_NEW                 - register_address_translation_unit
+          // out_INSERT_RAT_WRITE_RE                           - register_address_translation_unit
+          // out_INSERT_RAT_NUM_REG_RE_LOG                     - register_address_translation_unit
+          // out_INSERT_RAT_NUM_REG_RE_PHY_NEW                 - register_address_translation_unit
+        }
 …
                               dest,"out_RETIRE_"+toString(i)+"_ACK"          );
+          dest = _name+"_register_address_translation_unit";
+          PORT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_RAT_VAL"      ,
+                              dest, "in_RETIRE_"+toString(i)+"_VAL"          );
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_RAT_ACK"      ,
+                              dest,"out_RETIRE_"+toString(i)+"_ACK"          );
+          dest = _name+"_stat_list_unit";
+          PORT_MAP(_component,src ,"out_RETIRE_"+toString(i)+"_STAT_LIST_VAL",
+                              dest, "in_RETIRE_"+toString(i)+"_VAL");
+          PORT_MAP(_component,src , "in_RETIRE_"+toString(i)+"_STAT_LIST_ACK",
+                              dest,"out_RETIRE_"+toString(i)+"_ACK");
+          // out_RETIRE_RAT_VAL       - register_address_translation_unit
+          //  in_RETIRE_RAT_ACK       - register_address_translation_unit
+          // out_RETIRE_STAT_LIST_VAL - stat_list_unit
+          //  in_RETIRE_STAT_LIST_ACK - stat_list_unit
+        }
+     }
 …
     // ~~~~~[ Others ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     _component->test_map();
+#ifdef POSITION
+    _component->generate_file();
+#if (DEBUG_Register_translation_unit == true)
+    _component->test_map();
+#endif
+#ifdef POSITION
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Register_translation_unit_deallocation.cpp

r81	r88
23	23	log_printf(FUNC,Register_translation_unit,FUNCTION,"Begin");
24	24
25		if (~~_usage & USE_SYSTEMC~~)
	25	if (usage_is_set(_usage,USE_SYSTEMC))
26	26	{
27	27	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/src/Register_translation_unit_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/Makefile.deps

-              r81
+              r88
 include                         $(DIR_MORPHEO)/Behavioural/Makefile.deps
 endif
+ifndef Priority
+include                         $(DIR_MORPHEO)/Behavioural/Generic/Priority/Makefile.deps
+endif
 #-----[ Directory ]----------------------------------------
 Rename_select_DIR                       =       $(DIR_MORPHEO)/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select
+Rename_select_DIR               =       $(DIR_MORPHEO)/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select
 #-----[ Library ]------------------------------------------
+Rename_select_LIBRARY           =       -lRename_select \
+Rename_select_LIBRARY           =       -lRename_select                 \
+                                        $(Priority_LIBRARY)             \
                                         $(Behavioural_LIBRARY)
+Rename_select_DIR_LIBRARY               =       -L$(Rename_select_DIR)/lib      \
+Rename_select_DIR_LIBRARY       =       -L$(Rename_select_DIR)/lib      \
+                                        $(Priority_DIR_LIBRARY)         \
                                         $(Behavioural_DIR_LIBRARY)
 …
                                 @\
                                 $(MAKE) Behavioural_library;            \
+                                $(MAKE) Priority_library;               \
                                 $(MAKE) --directory=$(Rename_select_DIR) --makefile=Makefile;
 …
                                 @\
                                 $(MAKE) Behavioural_library_clean;      \
+                                $(MAKE) Priority_library_clean;         \
                                 $(MAKE) --directory=$(Rename_select_DIR) --makefile=Makefile clean;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/SelfTest/Makefile

r81	r88
24	24	library_clean : Rename_select_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/SelfTest/src/main.cpp

-              r81
+              r88
   err (_(" * nb_front_end                         (uint32_t         )\n"));
   err (_(" * nb_context            [nb_front_end] (uint32_t         )\n"));
+//   err (_(" * size_nb_front_end_id                 (uint32_t         )\n"));
+//   err (_(" * size_nb_context_id                   (uint32_t         )\n"));
   err (_(" * max_branch_speculated                (uint32_t         )\n"));
   err (_(" * size_general_data                    (uint32_t         )\n"));
 …
     _nb_context [i] = atoi(argv[x++]);
+//   uint32_t          _size_front_end_id    = atoi(argv[x++]);
+//   uint32_t          _size_context_id      = atoi(argv[x++]);
   uint32_t          _max_branch_speculated= atoi(argv[x++]);
   uint32_t          _size_general_data    = atoi(argv[x++]);
 …
         (_nb_front_end         ,
          _nb_context           ,
+//          _size_front_end_id    ,
+//          _size_context_id      ,
          _max_branch_speculated,
          _size_general_data    ,
 …
          _nb_front_end_select  ,
          _priority             ,
+         _load_balancing       );
+         _load_balancing       ,
+         true // is_toplevel
+         );
       msg(_("%s"),param->print(1).c_str());

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Rename_select * _Rename_select = new Rename_select
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC
 …
   sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_VAL           ," in_RENAME_IN_VAL           ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL(out_RENAME_IN_ACK           ,"out_RENAME_IN_ACK           ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_FRONT_END_ID  ," in_RENAME_IN_FRONT_END_ID  ",Tcontext_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_CONTEXT_ID    ," in_RENAME_IN_CONTEXT_ID    ",Tcontext_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_DEPTH         ," in_RENAME_IN_DEPTH         ",Tdepth_t          ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_TYPE          ," in_RENAME_IN_TYPE          ",Ttype_t           ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_OPERATION     ," in_RENAME_IN_OPERATION     ",Toperation_t      ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_ADDRESS       ," in_RENAME_IN_ADDRESS       ",Tgeneral_data_t   ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_HAS_IMMEDIAT  ," in_RENAME_IN_HAS_IMMEDIAT  ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_IMMEDIAT      ," in_RENAME_IN_IMMEDIAT      ",Tgeneral_data_t   ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_READ_RA       ," in_RENAME_IN_READ_RA       ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RA    ," in_RENAME_IN_NUM_REG_RA    ",Tgeneral_address_t,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_READ_RB       ," in_RENAME_IN_READ_RB       ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RB    ," in_RENAME_IN_NUM_REG_RB    ",Tgeneral_address_t,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_READ_RC       ," in_RENAME_IN_READ_RC       ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RC    ," in_RENAME_IN_NUM_REG_RC    ",Tspecial_address_t,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_WRITE_RD      ," in_RENAME_IN_WRITE_RD      ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RD    ," in_RENAME_IN_NUM_REG_RD    ",Tgeneral_address_t,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_WRITE_RE      ," in_RENAME_IN_WRITE_RE      ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RE    ," in_RENAME_IN_NUM_REG_RE    ",Tspecial_address_t,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_EXCEPTION_USE ," in_RENAME_IN_EXCEPTION_USE ",Texception_t      ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_VAL           ," in_RENAME_IN_VAL           ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL(out_RENAME_IN_ACK           ,"out_RENAME_IN_ACK           ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_FRONT_END_ID  ," in_RENAME_IN_FRONT_END_ID  ",Tcontext_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_CONTEXT_ID    ," in_RENAME_IN_CONTEXT_ID    ",Tcontext_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_DEPTH         ," in_RENAME_IN_DEPTH         ",Tdepth_t          ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_TYPE          ," in_RENAME_IN_TYPE          ",Ttype_t           ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_OPERATION     ," in_RENAME_IN_OPERATION     ",Toperation_t      ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NO_EXECUTE    ," in_RENAME_IN_NO_EXECUTE    ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_IS_DELAY_SLOT ," in_RENAME_IN_IS_DELAY_SLOT ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_ADDRESS       ," in_RENAME_IN_ADDRESS       ",Tgeneral_data_t   ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_HAS_IMMEDIAT  ," in_RENAME_IN_HAS_IMMEDIAT  ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_IMMEDIAT      ," in_RENAME_IN_IMMEDIAT      ",Tgeneral_data_t   ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_READ_RA       ," in_RENAME_IN_READ_RA       ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RA    ," in_RENAME_IN_NUM_REG_RA    ",Tgeneral_address_t,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_READ_RB       ," in_RENAME_IN_READ_RB       ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RB    ," in_RENAME_IN_NUM_REG_RB    ",Tgeneral_address_t,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_READ_RC       ," in_RENAME_IN_READ_RC       ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RC    ," in_RENAME_IN_NUM_REG_RC    ",Tspecial_address_t,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_WRITE_RD      ," in_RENAME_IN_WRITE_RD      ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RD    ," in_RENAME_IN_NUM_REG_RD    ",Tgeneral_address_t,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_WRITE_RE      ," in_RENAME_IN_WRITE_RE      ",Tcontrol_t        ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_NUM_REG_RE    ," in_RENAME_IN_NUM_REG_RE    ",Tspecial_address_t,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_EXCEPTION_USE ," in_RENAME_IN_EXCEPTION_USE ",Texception_t      ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  ALLOC2_SC_SIGNAL( in_RENAME_IN_EXCEPTION     ," in_RENAME_IN_EXCEPTION     ",Texception_t      ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_VAL          ,"out_RENAME_OUT_VAL          ",Tcontrol_t        ,_param->_nb_inst_rename);
 …
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_TYPE         ,"out_RENAME_OUT_TYPE         ",Ttype_t           ,_param->_nb_inst_rename);
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_OPERATION    ,"out_RENAME_OUT_OPERATION    ",Toperation_t      ,_param->_nb_inst_rename);
+  ALLOC1_SC_SIGNAL(out_RENAME_OUT_NO_EXECUTE   ,"out_RENAME_OUT_NO_EXECUTE   ",Tcontrol_t        ,_param->_nb_inst_rename);
+  ALLOC1_SC_SIGNAL(out_RENAME_OUT_IS_DELAY_SLOT,"out_RENAME_OUT_IS_DELAY_SLOT",Tcontrol_t        ,_param->_nb_inst_rename);
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_ADDRESS      ,"out_RENAME_OUT_ADDRESS      ",Tgeneral_data_t   ,_param->_nb_inst_rename);
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_HAS_IMMEDIAT ,"out_RENAME_OUT_HAS_IMMEDIAT ",Tcontrol_t        ,_param->_nb_inst_rename);
 …
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_NUM_REG_RE   ,"out_RENAME_OUT_NUM_REG_RE   ",Tspecial_address_t,_param->_nb_inst_rename);
   ALLOC1_SC_SIGNAL(out_RENAME_OUT_EXCEPTION_USE,"out_RENAME_OUT_EXCEPTION_USE",Texception_t      ,_param->_nb_inst_rename);
+  ALLOC1_SC_SIGNAL(out_RENAME_OUT_EXCEPTION    ,"out_RENAME_OUT_EXCEPTION    ",Texception_t      ,_param->_nb_inst_rename);
   /********************************************************
 …
   (*(_Rename_select->in_NRESET))       (*(in_NRESET));
   INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_VAL           ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
   INSTANCE2_SC_SIGNAL(_Rename_select,out_RENAME_IN_ACK           ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_VAL           ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select,out_RENAME_IN_ACK           ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
   if (_param->_have_port_front_end_id)
   INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_FRONT_END_ID  ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_FRONT_END_ID  ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
   if (_param->_have_port_context_id)
   INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_CONTEXT_ID    ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_CONTEXT_ID    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
   if (_param->_have_port_depth)
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_DEPTH         ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_TYPE          ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_OPERATION     ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_ADDRESS       ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_HAS_IMMEDIAT  ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_IMMEDIAT      ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_READ_RA       ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RA    ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_READ_RB       ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RB    ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_READ_RC       ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RC    ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_WRITE_RD      ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RD    ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_WRITE_RE      ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RE    ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_EXCEPTION_USE ,_param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_DEPTH         ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_TYPE          ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_OPERATION     ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NO_EXECUTE    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_IS_DELAY_SLOT ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_ADDRESS       ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_HAS_IMMEDIAT  ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_IMMEDIAT      ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_READ_RA       ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RA    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_READ_RB       ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RB    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_READ_RC       ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RC    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_WRITE_RD      ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RD    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_WRITE_RE      ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_NUM_REG_RE    ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_EXCEPTION_USE ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
+  INSTANCE2_SC_SIGNAL(_Rename_select, in_RENAME_IN_EXCEPTION     ,_param->_nb_front_end, _param->_nb_inst_decod[it1]);
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_VAL          ,_param->_nb_inst_rename);
 …
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_TYPE         ,_param->_nb_inst_rename);
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_OPERATION    ,_param->_nb_inst_rename);
+  INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_NO_EXECUTE   ,_param->_nb_inst_rename);
+  INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_IS_DELAY_SLOT,_param->_nb_inst_rename);
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_ADDRESS      ,_param->_nb_inst_rename);
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_HAS_IMMEDIAT ,_param->_nb_inst_rename);
 …
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_NUM_REG_RE   ,_param->_nb_inst_rename);
   INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_EXCEPTION_USE,_param->_nb_inst_rename);
+  INSTANCE1_SC_SIGNAL(_Rename_select,out_RENAME_OUT_EXCEPTION    ,_param->_nb_inst_rename);
   msg(_("<%s> : Start Simulation ............\n"),name.c_str());
 …
             in_RENAME_IN_TYPE         [i][j]->write(range<Ttype_t           >(rand(),_param->_size_type                  ));
             in_RENAME_IN_OPERATION    [i][j]->write(range<Toperation_t      >(rand(),_param->_size_operation             ));
+            in_RENAME_IN_NO_EXECUTE   [i][j]->write(rand()%2);
+            in_RENAME_IN_IS_DELAY_SLOT[i][j]->write(rand()%2);
             in_RENAME_IN_ADDRESS      [i][j]->write(address++                                                             );
             in_RENAME_IN_HAS_IMMEDIAT [i][j]->write(range<Tcontrol_t        >(rand(),1                                   ));
 …
             in_RENAME_IN_NUM_REG_RE   [i][j]->write(range<Tspecial_address_t>(rand(),_param->_size_special_register_logic));
             in_RENAME_IN_EXCEPTION_USE[i][j]->write(range<Texception_t      >(rand(),_param->_size_exception             ));
+            in_RENAME_IN_EXCEPTION    [i][j]->write(range<Texception_t      >(rand(),_param->_size_exception             ));
+          }
 …
                       TEST(Ttype_t           ,out_RENAME_OUT_TYPE         [i]->read(),in_RENAME_IN_TYPE         [x][y]->read());
                       TEST(Toperation_t      ,out_RENAME_OUT_OPERATION    [i]->read(),in_RENAME_IN_OPERATION    [x][y]->read());
+                      TEST(Tcontrol_t        ,out_RENAME_OUT_NO_EXECUTE   [i]->read(),in_RENAME_IN_NO_EXECUTE   [x][y]->read());
+                      TEST(Tcontrol_t        ,out_RENAME_OUT_IS_DELAY_SLOT[i]->read(),in_RENAME_IN_IS_DELAY_SLOT[x][y]->read());
                       TEST(Tcontrol_t        ,out_RENAME_OUT_HAS_IMMEDIAT [i]->read(),in_RENAME_IN_HAS_IMMEDIAT [x][y]->read());
                       TEST(Tgeneral_data_t   ,out_RENAME_OUT_IMMEDIAT     [i]->read(),in_RENAME_IN_IMMEDIAT     [x][y]->read());
 …
                       TEST(Tspecial_address_t,out_RENAME_OUT_NUM_REG_RE   [i]->read(),in_RENAME_IN_NUM_REG_RE   [x][y]->read());
                       TEST(Texception_t      ,out_RENAME_OUT_EXCEPTION_USE[i]->read(),in_RENAME_IN_EXCEPTION_USE[x][y]->read());
+                      TEST(Texception_t      ,out_RENAME_OUT_EXCEPTION    [i]->read(),in_RENAME_IN_EXCEPTION    [x][y]->read());
+                  }
 …
   delete []  in_RENAME_IN_TYPE          ;
   delete []  in_RENAME_IN_OPERATION     ;
+  delete []  in_RENAME_IN_NO_EXECUTE    ;
+  delete []  in_RENAME_IN_IS_DELAY_SLOT ;
   delete []  in_RENAME_IN_ADDRESS       ;
   delete []  in_RENAME_IN_HAS_IMMEDIAT  ;
 …
   delete []  in_RENAME_IN_NUM_REG_RE    ;
   delete []  in_RENAME_IN_EXCEPTION_USE ;
+  delete []  in_RENAME_IN_EXCEPTION     ;
   delete [] out_RENAME_OUT_VAL          ;
 …
   delete [] out_RENAME_OUT_TYPE         ;
   delete [] out_RENAME_OUT_OPERATION    ;
+  delete [] out_RENAME_OUT_NO_EXECUTE   ;
+  delete [] out_RENAME_OUT_IS_DELAY_SLOT;
   delete [] out_RENAME_OUT_ADDRESS      ;
   delete [] out_RENAME_OUT_HAS_IMMEDIAT ;
 …
   delete [] out_RENAME_OUT_NUM_REG_RE   ;
   delete [] out_RENAME_OUT_EXCEPTION_USE;
+  delete [] out_RENAME_OUT_EXCEPTION    ;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/include/Parameters.h

-              r82
+              r88
   public : uint32_t *        _nb_context            ;//[nb_front_end]
   public : uint32_t          _max_branch_speculated ;
   public : uint32_t          _size_general_data     ;
+//public : uint32_t          _size_general_data     ;
   public : uint32_t          _nb_inst_rename        ;
   public : uint32_t *        _nb_inst_decod         ;//[nb_front_end]
 …
   public : uint32_t          _max_nb_inst_decod     ;
+//public : uint32_t          _size_depth            ;
+//public : uint32_t          _size_front_end_id     ;
+//public : uint32_t          _size_context_id       ;
+  public : uint32_t          _size_front_end_id     ;
+  public : uint32_t          _size_context_id       ;
+  public : uint32_t          _size_depth            ;
+  public : bool              _have_port_front_end_id;
+  public : bool              _have_port_context_id  ;
+  public : bool              _have_port_depth       ;
+//public : bool              _have_port_front_end_id;
+//public : bool              _have_port_context_id  ;
+//public : bool              _have_port_depth       ;
     //-----[ methods ]-----------------------------------------------------------
   public : Parameters  (uint32_t          nb_front_end         ,
                         uint32_t *        nb_context           ,
+//                      uint32_t          size_front_end_id    ,
+//                      uint32_t          size_context_id      ,
                         uint32_t          max_branch_speculated,
                         uint32_t          size_general_data    ,
 …
                         uint32_t          nb_front_end_select  ,
                         Tpriority_t       priority             ,
+                        Tload_balancing_t load_balancing       );
+//   public : Parameters  (Parameters & param) ;
+                        Tload_balancing_t load_balancing       ,
+                        bool              is_toplevel=true);
+//public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/include/Rename_select.h

-              r82
+              r88
 #endif
-#include <iostream>
 #include "Common/include/ToString.h"
 #include "Common/include/Debug.h"
 …
 #endif
 #include "Behavioural/include/Usage.h"
+#include "Behavioural/Generic/Priority/include/Priority.h"
 #include <list>
+#include <iostream>
 namespace morpheo {
 …
   public    : SC_IN (Ttype_t           )  ***  in_RENAME_IN_TYPE          ;//[nb_front_end][nb_inst_decod]
   public    : SC_IN (Toperation_t      )  ***  in_RENAME_IN_OPERATION     ;//[nb_front_end][nb_inst_decod]
+  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_NO_EXECUTE    ;//[nb_front_end][nb_inst_decod]
+  public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_IS_DELAY_SLOT ;//[nb_front_end][nb_inst_decod]
   public    : SC_IN (Tgeneral_data_t   )  ***  in_RENAME_IN_ADDRESS       ;//[nb_front_end][nb_inst_decod]
   public    : SC_IN (Tcontrol_t        )  ***  in_RENAME_IN_HAS_IMMEDIAT  ;//[nb_front_end][nb_inst_decod]
 …
   public    : SC_IN (Tspecial_address_t)  ***  in_RENAME_IN_NUM_REG_RE    ;//[nb_front_end][nb_inst_decod]
   public    : SC_IN (Texception_t      )  ***  in_RENAME_IN_EXCEPTION_USE ;//[nb_front_end][nb_inst_decod]
+  public    : SC_IN (Texception_t      )  ***  in_RENAME_IN_EXCEPTION     ;//[nb_front_end][nb_inst_decod]
     // ~~~~~[ Interface : "rename_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
   public    : SC_OUT(Ttype_t           )   ** out_RENAME_OUT_TYPE         ;//[nb_inst_rename]
   public    : SC_OUT(Toperation_t      )   ** out_RENAME_OUT_OPERATION    ;//[nb_inst_rename]
+  public    : SC_OUT(Tcontrol_t        )   ** out_RENAME_OUT_NO_EXECUTE   ;//[nb_inst_rename]
+  public    : SC_OUT(Tcontrol_t        )   ** out_RENAME_OUT_IS_DELAY_SLOT;//[nb_inst_rename]
   public    : SC_OUT(Tgeneral_data_t   )   ** out_RENAME_OUT_ADDRESS      ;//[nb_inst_rename]
   public    : SC_OUT(Tcontrol_t        )   ** out_RENAME_OUT_HAS_IMMEDIAT ;//[nb_inst_rename]
 …
   public    : SC_OUT(Tspecial_address_t)   ** out_RENAME_OUT_NUM_REG_RE   ;//[nb_inst_rename]
   public    : SC_OUT(Texception_t      )   ** out_RENAME_OUT_EXCEPTION_USE;//[nb_inst_rename]
+  public    : SC_OUT(Texception_t      )   ** out_RENAME_OUT_EXCEPTION    ;//[nb_inst_rename]
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  private   : generic::priority::Priority   * _priority;
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  private   : uint32_t                        reg_FRONT_END_PRIORITY;
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  private   : std::list<select_t>             select;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/include/Types.h

-              r81
+              r88
 namespace rename_select {
-  class select_t
+  {
-  public : uint32_t _front_end ;
-  public : uint32_t _inst_decod;
-  public : select_t (uint32_t front_end,
-                     uint32_t inst_decod)
+    {
-      _front_end  = front_end ;
-      _inst_decod = inst_decod;
+    }
-  };
 }; // end namespace rename_select
 }; // end namespace rename_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Parameters.cpp

-              r81
+              r88
   Parameters::Parameters (uint32_t          nb_front_end         ,
                           uint32_t *        nb_context           ,
+//                           uint32_t          size_front_end_id    ,
+//                           uint32_t          size_context_id      ,
                           uint32_t          max_branch_speculated,
                           uint32_t          size_general_data    ,
 …
                           uint32_t          nb_front_end_select  ,
                           Tpriority_t       priority             ,
+                          Tload_balancing_t load_balancing       )
+                          Tload_balancing_t load_balancing       ,
+                          bool              is_toplevel)
+  {
     log_printf(FUNC,Rename_select,FUNCTION,"Begin");
 …
     _nb_context            = nb_context           ;
     _max_branch_speculated = max_branch_speculated;
-    _size_general_data     = size_general_data    ;
     _nb_inst_rename        = nb_inst_rename       ;
     _nb_inst_decod         = nb_inst_decod        ;
 …
     _max_nb_inst_decod     = max<uint32_t>(nb_inst_decod,nb_front_end);
+    _size_front_end_id     = log2(nb_front_end);
+    _size_context_id       = log2(max<uint32_t>(nb_context,nb_front_end));
+    _size_depth            = log2(max_branch_speculated);
+    test();
+    _have_port_front_end_id= _size_front_end_id > 0;
+    _have_port_context_id  = _size_context_id   > 0;
+    _have_port_depth       = _size_depth        > 0;
+    if (is_toplevel)
+      {
+        _size_general_data     = size_general_data    ;
+        _size_depth            = log2(max_branch_speculated);
+        _size_front_end_id     = log2(_nb_front_end);
+        _size_context_id       = log2(max<uint32_t>(_nb_context,_nb_front_end));
+    test();
+        _have_port_front_end_id= _size_front_end_id > 0;
+        _have_port_context_id  = _size_context_id   > 0;
+        _have_port_depth       = _size_depth        > 0;
+        copy();
+      }
     log_printf(FUNC,Rename_select,FUNCTION,"End");
   };
 …
   };
+#undef  FUNCTION
+#define FUNCTION "Rename_select::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Rename_select,FUNCTION,"Begin");
+    log_printf(FUNC,Rename_select,FUNCTION,"End");
+  };
 }; // end namespace rename_select
 }; // end namespace rename_unit

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select.cpp

-              r81
+              r88
     log_printf(FUNC,Rename_select,FUNCTION,"Begin");
+#if DEBUG_Core == true
+    log_printf(INFO,Core,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Rename_select,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Rename_select,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Rename_select,FUNCTION,"Method - transition");
 …
                         << (*(in_RENAME_IN_TYPE          [i][j]))
                         << (*(in_RENAME_IN_OPERATION     [i][j]))
+                        << (*(in_RENAME_IN_NO_EXECUTE    [i][j]))
+                        << (*(in_RENAME_IN_IS_DELAY_SLOT [i][j]))
                         << (*(in_RENAME_IN_ADDRESS       [i][j]))
                         << (*(in_RENAME_IN_HAS_IMMEDIAT  [i][j]))
 …
                         << (*(in_RENAME_IN_WRITE_RE      [i][j]))
                         << (*(in_RENAME_IN_NUM_REG_RE    [i][j]))
+                        << (*(in_RENAME_IN_EXCEPTION_USE [i][j]));
+                        << (*(in_RENAME_IN_EXCEPTION_USE [i][j]))
+                        << (*(in_RENAME_IN_EXCEPTION     [i][j]));
               if (_param->_have_port_front_end_id)
               sensitive << (*(in_RENAME_IN_FRONT_END_ID  [i][j]));
 …
                   (*(out_RENAME_OUT_OPERATION     [x])) (*(in_RENAME_IN_VAL           [i][j]));
                   (*(out_RENAME_OUT_OPERATION     [x])) (*(in_RENAME_IN_OPERATION     [i][j]));
+                  (*(out_RENAME_OUT_NO_EXECUTE    [x])) (*(in_RENAME_IN_VAL           [i][j]));
+                  (*(out_RENAME_OUT_NO_EXECUTE    [x])) (*(in_RENAME_IN_NO_EXECUTE    [i][j]));
+                  (*(out_RENAME_OUT_IS_DELAY_SLOT [x])) (*(in_RENAME_IN_VAL           [i][j]));
+                  (*(out_RENAME_OUT_IS_DELAY_SLOT [x])) (*(in_RENAME_IN_IS_DELAY_SLOT [i][j]));
                   (*(out_RENAME_OUT_ADDRESS       [x])) (*(in_RENAME_IN_VAL           [i][j]));
                   (*(out_RENAME_OUT_ADDRESS       [x])) (*(in_RENAME_IN_ADDRESS       [i][j]));
 …
                   (*(out_RENAME_OUT_EXCEPTION_USE [x])) (*(in_RENAME_IN_VAL           [i][j]));
                   (*(out_RENAME_OUT_EXCEPTION_USE [x])) (*(in_RENAME_IN_EXCEPTION_USE [i][j]));
+                  (*(out_RENAME_OUT_EXCEPTION     [x])) (*(in_RENAME_IN_VAL           [i][j]));
+                  (*(out_RENAME_OUT_EXCEPTION     [x])) (*(in_RENAME_IN_EXCEPTION     [i][j]));
+                }
+          }
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Rename_select,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_allocation.cpp

-              r81
+              r88
     // ~~~~~[ Interface : "rename_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       ALLOC2_INTERFACE("rename_in", IN, EAST, "output of decod's stage", _param->_nb_front_end, _param->_nb_inst_decod[alloc_interface_it1]);
+      ALLOC2_INTERFACE("rename_in", IN, EAST, "output of decod's stage", _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_VALACK_IN ( in_RENAME_IN_VAL           ,VAL, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_VALACK_OUT(out_RENAME_IN_ACK           ,ACK, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_FRONT_END_ID  ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id          , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_CONTEXT_ID    ,"context_id"   ,Tcontext_t        ,_param->_size_context_id            , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_DEPTH         ,"depth"        ,Tdepth_t          ,_param->_size_depth                 , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_TYPE          ,"type"         ,Ttype_t           ,_param->_size_type                  , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_OPERATION     ,"operation"    ,Toperation_t      ,_param->_size_operation             , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_ADDRESS       ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data          , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_HAS_IMMEDIAT  ,"has_immediat" ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_IMMEDIAT      ,"immediat"     ,Tgeneral_data_t   ,_param->_size_general_data          , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_READ_RA       ,"read_ra"      ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RA    ,"num_reg_ra"   ,Tgeneral_address_t,_param->_size_general_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_READ_RB       ,"read_rb"      ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RB    ,"num_reg_rb"   ,Tgeneral_address_t,_param->_size_general_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_READ_RC       ,"read_rc"      ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RC    ,"num_reg_rc"   ,Tspecial_address_t,_param->_size_special_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_WRITE_RD      ,"write_rd"     ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RD    ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_WRITE_RE      ,"write_re"     ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RE    ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_EXCEPTION_USE ,"exception_use",Texception_t      ,_param->_size_exception             , _param->_nb_front_end, _param->_nb_inst_decod[alloc_signal_it1]);
+      _ALLOC2_VALACK_IN ( in_RENAME_IN_VAL           ,VAL, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_VALACK_OUT(out_RENAME_IN_ACK           ,ACK, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_FRONT_END_ID  ,"front_end_id" ,Tcontext_t        ,_param->_size_front_end_id          , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_CONTEXT_ID    ,"context_id"   ,Tcontext_t        ,_param->_size_context_id            , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_DEPTH         ,"depth"        ,Tdepth_t          ,_param->_size_depth                 , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_TYPE          ,"type"         ,Ttype_t           ,_param->_size_type                  , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_OPERATION     ,"operation"    ,Toperation_t      ,_param->_size_operation             , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NO_EXECUTE    ,"no_execute"   ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_IS_DELAY_SLOT ,"is_delay_slot",Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_ADDRESS       ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data          , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_HAS_IMMEDIAT  ,"has_immediat" ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_IMMEDIAT      ,"immediat"     ,Tgeneral_data_t   ,_param->_size_general_data          , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_READ_RA       ,"read_ra"      ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RA    ,"num_reg_ra"   ,Tgeneral_address_t,_param->_size_general_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_READ_RB       ,"read_rb"      ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RB    ,"num_reg_rb"   ,Tgeneral_address_t,_param->_size_general_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_READ_RC       ,"read_rc"      ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RC    ,"num_reg_rc"   ,Tspecial_address_t,_param->_size_special_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_WRITE_RD      ,"write_rd"     ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RD    ,"num_reg_rd"   ,Tgeneral_address_t,_param->_size_general_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_WRITE_RE      ,"write_re"     ,Tcontrol_t        ,1                                   , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_NUM_REG_RE    ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register_logic, _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_EXCEPTION_USE ,"exception_use",Texception_t      ,_param->_size_exception             , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+      _ALLOC2_SIGNAL_IN ( in_RENAME_IN_EXCEPTION     ,"exception"    ,Texception_t      ,_param->_size_exception             , _param->_nb_front_end, _param->_nb_inst_decod[it1]);
+    }
 …
       ALLOC1_SIGNAL_OUT(out_RENAME_OUT_TYPE          ,"type"         ,Ttype_t           ,_param->_size_type                  );
       ALLOC1_SIGNAL_OUT(out_RENAME_OUT_OPERATION     ,"operation"    ,Toperation_t      ,_param->_size_operation             );
+      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_NO_EXECUTE    ,"no_execute"   ,Tcontrol_t        ,1                                   );
+      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_IS_DELAY_SLOT ,"is_delay_slot",Tcontrol_t        ,1                                   );
       ALLOC1_SIGNAL_OUT(out_RENAME_OUT_ADDRESS       ,"address"      ,Tgeneral_data_t   ,_param->_size_general_data          );
       ALLOC1_SIGNAL_OUT(out_RENAME_OUT_HAS_IMMEDIAT  ,"has_immediat" ,Tcontrol_t        ,1                                   );
 …
       ALLOC1_SIGNAL_OUT(out_RENAME_OUT_NUM_REG_RE    ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register_logic);
       ALLOC1_SIGNAL_OUT(out_RENAME_OUT_EXCEPTION_USE ,"exception_use",Texception_t      ,_param->_size_exception             );
+      ALLOC1_SIGNAL_OUT(out_RENAME_OUT_EXCEPTION     ,"exception"    ,Texception_t      ,_param->_size_exception             );
+    }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    _priority = new generic::priority::Priority (_name+"_priority"      ,
+                                                 _param->_priority      ,
+                                                 _param->_load_balancing,
+                                                 _param->_nb_front_end  ,
+                                                 _param->_nb_inst_decod ,
+                                                 _param->_nb_front_end_select);
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Rename_select,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         delete []  in_RENAME_IN_TYPE          ;
         delete []  in_RENAME_IN_OPERATION     ;
+        delete []  in_RENAME_IN_NO_EXECUTE    ;
+        delete []  in_RENAME_IN_IS_DELAY_SLOT ;
         delete []  in_RENAME_IN_ADDRESS       ;
         delete []  in_RENAME_IN_HAS_IMMEDIAT  ;
 …
         delete []  in_RENAME_IN_NUM_REG_RE    ;
         delete []  in_RENAME_IN_EXCEPTION_USE ;
+        delete []  in_RENAME_IN_EXCEPTION     ;
         delete [] out_RENAME_OUT_VAL          ;
 …
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete _priority;
     delete _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_genMealy.cpp

-              r81
+              r88
   void Rename_select::genMealy (void)
+  {
+    log_printf(FUNC,Rename_select,FUNCTION,"Begin");
+    log_begin(Rename_select,FUNCTION);
+    log_function(Rename_select,FUNCTION,_name.c_str());
+    Tcontrol_t ack [_param->_nb_front_end][_param->_max_nb_inst_decod];
+    Tcontrol_t val                  [_param->_nb_inst_rename];
+    Tcontrol_t ack                  [_param->_nb_front_end][_param->_max_nb_inst_decod];
+    Tcontrol_t previous_transaction [_param->_nb_front_end];
+    for (uint32_t i=0; i<_param->_nb_inst_rename; ++i)
+      val [i] = false;
     for (uint32_t i=0; i<_param->_nb_front_end; i++)
+      for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+        ack [i][j] = false;
+    std::list<select_t>::iterator it=select.begin();
+      {
+        previous_transaction [i] = true;
+        for (uint32_t j=0; j<_param->_nb_inst_decod[i]; j++)
+          ack [i][j] = false;
+      }
+    std::list<generic::priority::select_t> * select = _priority->select();
+    std::list<generic::priority::select_t>::iterator it=select->begin();
     for (uint32_t i=0; i<_param->_nb_inst_rename; i++)
+      {
         Tcontrol_t val = false;
+        log_printf(TRACE,Rename_select,FUNCTION,"  * inst_rename [%d]",i);
+        while ((it != select.end()) and (val == false))
+        // Scan all instruction until find
+        while ((it != select->end()) and (val [i] == false))
+          {
             Tcontext_t x = it->_front_end ;
             uint32_t   y = it->_inst_decod;
+            Tcontext_t x = it->grp;
+            uint32_t   y = it->elt;
+            // Test if this instruction is valid
+            if (PORT_READ(in_RENAME_IN_VAL[x][y]) == 1)
+            log_printf(TRACE,Rename_select,FUNCTION,"    * front_end[%d].inst_decod[%d]",x,y);
+            log_printf(TRACE,Rename_select,FUNCTION,"      * rename_in_val        : %d",PORT_READ(in_RENAME_IN_VAL[x][y]));
+            log_printf(TRACE,Rename_select,FUNCTION,"      * previous_transaction : %d",previous_transaction[x]);
+            // Test if this instruction is valid and if all previous instruction of this front end is an valid transaction
+            if (previous_transaction [x] and
+                PORT_READ(in_RENAME_IN_VAL[x][y]))
+              {
                 // Find !!!
                 val        = true;
+                val [i]    = true;
                 ack [x][y] = PORT_READ(in_RENAME_OUT_ACK [i]);
+                log_printf(TRACE,Rename_select,FUNCTION,"      * rename_out_ack       : %d",PORT_READ(in_RENAME_OUT_ACK[i]));
                 if (_param->_have_port_front_end_id)
 …
                 PORT_WRITE(out_RENAME_OUT_TYPE         [i],PORT_READ(in_RENAME_IN_TYPE          [x][y]));
                 PORT_WRITE(out_RENAME_OUT_OPERATION    [i],PORT_READ(in_RENAME_IN_OPERATION     [x][y]));
+                PORT_WRITE(out_RENAME_OUT_NO_EXECUTE   [i],PORT_READ(in_RENAME_IN_NO_EXECUTE    [x][y]));
+                PORT_WRITE(out_RENAME_OUT_IS_DELAY_SLOT[i],PORT_READ(in_RENAME_IN_IS_DELAY_SLOT [x][y]));
                 PORT_WRITE(out_RENAME_OUT_ADDRESS      [i],PORT_READ(in_RENAME_IN_ADDRESS       [x][y]));
                 PORT_WRITE(out_RENAME_OUT_HAS_IMMEDIAT [i],PORT_READ(in_RENAME_IN_HAS_IMMEDIAT  [x][y]));
 …
                 PORT_WRITE(out_RENAME_OUT_NUM_REG_RE   [i],PORT_READ(in_RENAME_IN_NUM_REG_RE    [x][y]));
                 PORT_WRITE(out_RENAME_OUT_EXCEPTION_USE[i],PORT_READ(in_RENAME_IN_EXCEPTION_USE [x][y]));
+                PORT_WRITE(out_RENAME_OUT_EXCEPTION    [i],PORT_READ(in_RENAME_IN_EXCEPTION     [x][y]));
+              }
+            // ack = 1 if previous_transaction == true and rename_in_val == true and rename_out == true
+            previous_transaction [x] = ack [x][y];
             it ++;
+          }
-        PORT_WRITE(out_RENAME_OUT_VAL [i], val);
+      }
+    for (uint32_t i=0; i<_param->_nb_inst_rename; ++i)
+      PORT_WRITE(out_RENAME_OUT_VAL [i], val [i]);
     for (uint32_t i=0; i<_param->_nb_front_end; i++)
 …
         PORT_WRITE(out_RENAME_IN_ACK [i][j], ack [i][j]);
     log_printf(FUNC,Rename_select,FUNCTION,"End");
+    log_end(Rename_select,FUNCTION);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select/src/Rename_select_transition.cpp

-              r81
+              r88
     if (PORT_READ(in_NRESET) == 0)
+      {
+        select.clear();
+        reg_FRONT_END_PRIORITY = 0;
+        _priority->reset();
+      }
     else
+      {
+        switch (_param->_priority)
+          {
+          case PRIORITY_STATIC :
+            {
+              reg_FRONT_END_PRIORITY = (reg_FRONT_END_PRIORITY+_param->_nb_front_end_select)%_param->_nb_front_end;
+              break;
+            }
+          case PRIORITY_ROUND_ROBIN :
+            {
+              reg_FRONT_END_PRIORITY = (reg_FRONT_END_PRIORITY+1)%_param->_nb_front_end;
+              break;
+            }
+          default:
+            {
+              break;
+            }
+          }
+        // flush list
+        select.clear();
+        // Compute next scan order !!!
+        switch (_param->_load_balancing)
+          {
+          case LOAD_BALANCING_BALANCE :
+            {
+              for (uint32_t j=0; j<_param->_max_nb_inst_decod; j++)
+                for (uint32_t i=0; i<_param->_nb_front_end_select; i++)
+                  {
+                    uint32_t x=(reg_FRONT_END_PRIORITY+i)%_param->_nb_front_end;
+                    // Test valid inst_decod
+                    if (j < _param->_nb_inst_decod[x])
+                      select.push_back(select_t(x,j));
+                  }
+              break;
+            }
+          case LOAD_BALANCING_MAXIMUM_FOR_PRIORITY :
+            {
+              for (uint32_t i=0; i<_param->_nb_front_end_select; i++)
+                {
+                  uint32_t x=(reg_FRONT_END_PRIORITY+i)%_param->_nb_front_end;
+                  for (uint32_t j=0; j<_param->_nb_inst_decod[x]; j++)
+                    select.push_back(select_t(x,j));
+                }
+              break;
+            }
+          default :
+            {
+              break;
+            }
+          }
+        _priority->transition();
 // #if (DEBUG >= DEBUG_TRACE)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Custom/include/Custom_default.h

-              r81
+              r88
   custom_vhdl_t               * default_get_vhdl_execute              (void);
+  custom_information_t          default_get_custom_information        (uint32_t     context);
+//custom_information_t          default_get_custom_information        (uint32_t     context);
+  custom_information_t          default_get_custom_information        (void);
 }; // end namespace custom

trunk/IPs/systemC/processor/Morpheo/Behavioural/Custom/include/Custom_example.h

-              r81
+              r88
   custom_vhdl_t               * example_get_vhdl_execute              (void);
+  custom_information_t          example_get_custom_information        (uint32_t     context);
+//custom_information_t          example_get_custom_information        (uint32_t     context);
+  custom_information_t          example_get_custom_information        (void);
 }; // end namespace custom

trunk/IPs/systemC/processor/Morpheo/Behavioural/Custom/src/Custom_default.cpp

-              r81
+              r88
 #undef  FUNCTION
 #define FUNCTION "custom::default_get_custom_information"
+  custom_information_t default_get_custom_information (uint32_t context)
+//custom_information_t default_get_custom_information (uint32_t context)
+  custom_information_t default_get_custom_information (void)
+  {
     custom_information_t info;
 …
     info._get_vhdl_decod                = &morpheo::behavioural::custom::default_get_vhdl_decod               ;
     info._get_vhdl_execute              = &morpheo::behavioural::custom::default_get_vhdl_execute             ;
     return info;
+  }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Custom/src/Custom_example.cpp

-              r81
+              r88
 #undef  FUNCTION
 #define FUNCTION "custom::example_get_custom_information"
+  custom_information_t example_get_custom_information (uint32_t context)
+  {
+    // for all context
+//custom_information_t example_get_custom_information (uint32_t context)
+  custom_information_t example_get_custom_information (void)
+  {
     custom_information_t info;
 …
     info._get_vhdl_decod                = &morpheo::behavioural::custom::example_get_vhdl_decod               ;
     info._get_vhdl_execute              = &morpheo::behavioural::custom::example_get_vhdl_execute             ;
     return info;
+  }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/SelfTest/Makefile

r81	r88
24	24	library_clean : Counter_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Counter * _Counter = new Counter (name.c_str(),
 #ifdef STATISTICS
 …
 #endif
                                     param,
                                     USE_ALL);
+                                    _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/include/Counter.h

-              r82
+              r88
   public  :          ~Counter             (void);
-#ifdef SYSTEMC
   private : void     allocation                (void);
   private : void     deallocation              (void);
+#ifdef SYSTEMC
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
   public  : void     transition                (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/include/Parameters.h

-              r81
+              r88
   public : Parameters  (uint32_t size_data,
                         uint32_t nb_port  );
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void             copy       (void);
   public :        Parameters_test  msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/src/Counter.cpp

-              r82
+              r88
     log_printf(FUNC,Counter,"Counter","Begin");
+#ifdef SYSTEMC
+#if DEBUG_Counter == true
+    log_printf(INFO,Counter,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << param << std::endl;
+#endif
+    log_printf(INFO,Core,FUNCTION,_("<%s> Allocation"),_name.c_str());
     allocation ();
-#endif
 #ifdef STATISTICS
+    // Allocation of statistics
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,Core,FUNCTION,_("<%s> Allocation of statistics"),_name.c_str());
+        // Allocation of statistics
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,Core,FUNCTION,_("<%s> Generate the vhdl"),_name.c_str());
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
+    SC_METHOD (transition);
+    dont_initialize ();
+    sensitive << (*(in_CLOCK)).pos();
+        log_printf(INFO,Core,FUNCTION,_("<%s> Method - transition"),_name.c_str());
+        SC_METHOD (transition);
+        dont_initialize ();
+        sensitive << (*(in_CLOCK)).pos();
 #endif
+    SC_METHOD (genMealy);
+    dont_initialize ();
+    for (uint32_t i=0; i<_param._nb_port; i++)
+      sensitive << *(in_COUNTER_DATA   [i])
+                << *(in_COUNTER_ADDSUB [i]);
+        log_printf(INFO,Core,FUNCTION,_("<%s> Method - genMealy"),_name.c_str());
+        SC_METHOD (genMealy);
+        dont_initialize ();
+        for (uint32_t i=0; i<_param._nb_port; i++)
+          sensitive << *(in_COUNTER_DATA   [i])
+                    << *(in_COUNTER_ADDSUB [i]);
 #ifdef SYSTEMCASS_SPECIFIC
+    // List dependency information
+    for (uint32_t i=0; i<_param._nb_port; i++)
+      {
+        (*(out_COUNTER_DATA [i])) (*(in_COUNTER_DATA   [i]));
+        (*(out_COUNTER_DATA [i])) (*(in_COUNTER_ADDSUB [i]));
+        // List dependency information
+        for (uint32_t i=0; i<_param._nb_port; i++)
+          {
+            (*(out_COUNTER_DATA [i])) (*(in_COUNTER_DATA   [i]));
+            (*(out_COUNTER_DATA [i])) (*(in_COUNTER_ADDSUB [i]));
+          }
+#endif
+      }
-#endif
 #endif
 …
+  {
     log_printf(FUNC,Counter,"~Counter","Begin");
+#ifdef SYSTEMC
+    deallocation ();
+#ifdef STATISTICS
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        delete _stat;
+      }
 #endif
+#ifdef STATISTICS
     delete _stat;
+#endif
+    log_printf(INFO,Core,FUNCTION,_("<%s> Deallocation"),_name.c_str());
+    deallocation ();
     log_printf(FUNC,Counter,"~Counter","End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/src/Counter_allocation.cpp

-              r82
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    {
       Interface * interface = _interfaces->set_interface(""
 …
+    }
     // ~~~~~[ Interface : "counter" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "counter" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+     {
         in_COUNTER_DATA  = new SC_IN (Tdata_t)    * [_param._nb_port];
 …
+         }
+     }
 #ifdef POSITION
+    _component->generate_file();
+     if (usage_is_set(_usage,USE_POSITION))
+       _component->generate_file();
 #endif
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     log_printf(FUNC,Counter,"allocation","End");
   };
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/src/Counter_deallocation.cpp

-              r81
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
     log_printf(FUNC,Counter,"deallocation","Begin");
+    delete     in_CLOCK;
+    delete     in_NRESET;
+    delete []  in_COUNTER_DATA  ;
+    delete []  in_COUNTER_ADDSUB;
+    delete [] out_COUNTER_DATA  ;
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        delete     in_CLOCK;
+        delete     in_NRESET;
+        delete []  in_COUNTER_DATA  ;
+        delete []  in_COUNTER_ADDSUB;
+        delete [] out_COUNTER_DATA  ;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/src/Counter_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Counter/src/Parameters.cpp

-              r81
+              r88
   };
   Parameters::Parameters (Parameters & param):
     _size_data(param._size_data),
     _nb_port  (param._nb_port  ),
     _data_max (param._data_max )
+  {
     log_printf(FUNC,Counter,"Parameters","Begin");
     test();
     log_printf(FUNC,Counter,"Parameters","End");
   };
+//   Parameters::Parameters (Parameters & param):
+//     _size_data(param._size_data),
+//     _nb_port  (param._nb_port  ),
+//     _data_max (param._data_max )
+//   {
+//     log_printf(FUNC,Counter,"Parameters","Begin");
+//     test();
+//     log_printf(FUNC,Counter,"Parameters","End");
+//   };
   Parameters::~Parameters ()
 …
   };
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Counter,"copy","Begin");
+    log_printf(FUNC,Counter,"copy","End");
+  };
 }; // end namespace counter
 }; // end namespace generic
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/SelfTest/Makefile

r81	r88
24	24	library_clean : Queue_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Queue * _Queue = new Queue
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/include/Parameters.h

-              r81
+              r88
   public : Parameters  (uint32_t size_queue,
                         uint32_t size_data );
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Parameters.cpp

-              r81
+              r88
   };
+// #undef  FUNCTION
+// #define FUNCTION "Queue::Parameters (copy)"
+//   Parameters::Parameters (Parameters & param):
+//     _size_queue (param._size_queue),
+//     _size_data  (param._size_data )
+//   {
+//     log_printf(FUNC,Queue,FUNCTION,"Begin");
+//     test();
+//     log_printf(FUNC,Queue,FUNCTION,"End");
+//   };
 #undef  FUNCTION
+#define FUNCTION "Queue::Parameters (copy)"
+  Parameters::Parameters (Parameters & param):
+    _size_queue (param._size_queue),
+    _size_data  (param._size_data )
+#define FUNCTION "Queue::~Parameters"
+  Parameters::~Parameters ()
+  {
     log_printf(FUNC,Queue,FUNCTION,"Begin");
-    test();
     log_printf(FUNC,Queue,FUNCTION,"End");
   };
 #undef  FUNCTION
 #define FUNCTION "Queue::~Parameters"
   Parameters::~Parameters ()
+#define FUNCTION "Queue::copy"
+  void Parameters::copy (void)
+  {
     log_printf(FUNC,Queue,FUNCTION,"Begin");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue.cpp

-              r81
+              r88
     log_printf(FUNC,Queue,FUNCTION,"Begin");
+#if DEBUG_Core == true
+    log_printf(INFO,Core,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Queue,FUNCTION,"Allocation");
     allocation ();
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Queue,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Queue,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Queue,FUNCTION,"Generate Statistics file");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue_allocation.cpp

-              r81
+              r88
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     _queue_control = new morpheo::behavioural::generic::queue_control::Queue_Control::Queue_Control(_param->_size_queue);
     _queue_data    = new Tdata_t [_param->_size_queue];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue_deallocation.cpp

-              r81
+              r88
     log_printf(FUNC,Queue,FUNCTION,"Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete    in_CLOCK ;
 …
         delete   out_RETIRE_DATA;
+        // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        delete _queue_control;
+        delete _queue_data;
+      }
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    delete _queue_control;
+    delete _queue_data;
     delete _component;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Queue/src/Queue_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/SelfTest/Makefile

r81	r88
23	23	library_clean : RegisterFile_Monolithic_library_clean
24	24
	25	local_clean :
	26
25	27	include ../Makefile.deps
26	28	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/SelfTest/src/test.cpp

-              r82
+              r88
       exit (EXIT_FAILURE);
+    }
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
 #ifdef STATISTICS
 …
 #endif
      ,_param
      ,USE_ALL);
+     ,_usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/include/Parameters.h

-              r81
+              r88
                        uint32_t nb_word      ,
                        uint32_t size_word    );
   public : Parameters (Parameters & param) ;
+//   public : Parameters (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string   print      (uint32_t depth);
   public : friend std::ostream& operator<< (std::ostream& output_stream,

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/Parameters.cpp

-              r81
+              r88
   };
+  Parameters::Parameters (Parameters & param) :
+    _nb_port_read      (param._nb_port_read ),
+    _nb_port_write     (param._nb_port_write),
+    _nb_port_read_write(param._nb_port_read_write),
+    _nb_word           (param._nb_word      ),
+    _size_word         (param._size_word    ),
+    _size_address      (param._size_address ),
+    _have_port_address (param._have_port_address)
+//   Parameters::Parameters (Parameters & param) :
+//     _nb_port_read      (param._nb_port_read ),
+//     _nb_port_write     (param._nb_port_write),
+//     _nb_port_read_write(param._nb_port_read_write),
+//     _nb_word           (param._nb_word      ),
+//     _size_word         (param._size_word    ),
+//     _size_address      (param._size_address ),
+//     _have_port_address (param._have_port_address)
+//   {
+//     test();
+//   };
+  Parameters::~Parameters ()
+  {
-    test();
   };
+  Parameters::~Parameters ()
+  { };
+  void Parameters::copy (void)
+  {
+  };
 }; // end namespace registerfile_monolithic

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic.cpp

-              r81
+              r88
     log_printf(FUNC,RegisterFile_Monolithic,"RegisterFile_Monolithic","Begin");
+#if DEBUG_RegisterFile_Monolithic == true
+    log_printf(INFO,RegisterFile_Monolithic,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,RegisterFile_Monolithic,"RegisterFile_Monolithic","Allocation");
     allocation ();
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
       statistics_declaration(param_statistics);
 #endif
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         SC_METHOD (transition);
 …
+  {
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
       delete _stat;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_allocation.cpp

-              r81
+              r88
     // ----- Register
+    reg_DATA = new Tdata_t [_param->_nb_word];
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      reg_DATA = new Tdata_t [_param->_nb_word];
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_deallocation.cpp

r81	r88
18	18	delete _component;
19	19
20		if (~~_usage & USE_SYSTEMC~~)
	20	if (usage_is_set(_usage,USE_SYSTEMC))
21	21	{
22	22	delete in_CLOCK;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Monolithic/src/RegisterFile_Monolithic_transition.cpp

-              r81
+              r88
+          {
 #ifdef STATISTICS
+            (*_stat_nb_write) ++;
+            if (usage_is_set(_usage,USE_STATISTICS))
+              (*_stat_nb_write) ++;
 #endif
 …
+              {
 #ifdef STATISTICS
+                (*_stat_nb_write) ++;
+                if (usage_is_set(_usage,USE_STATISTICS))
+                  (*_stat_nb_write) ++;
 #endif
 …
             else
+              {
+                (*_stat_nb_read) ++;
+                if (usage_is_set(_usage,USE_STATISTICS))
+                  (*_stat_nb_read) ++;
+              }
 #endif
 …
 #ifdef STATISTICS
+    for (uint32_t i=0; i<_param->_nb_port_read; i++)
+      if ( PORT_READ(in_READ_VAL [i]) == 1)
+        (*_stat_nb_read) ++;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      for (uint32_t i=0; i<_param->_nb_port_read; i++)
+        if ( PORT_READ(in_READ_VAL [i]) == 1)
+          (*_stat_nb_read) ++;
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/SelfTest/Makefile

r81	r88
24	24	library_clean : RegisterFile_Multi_Banked_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   RegisterFile_Multi_Banked * _RegisterFile_Multi_Banked = new RegisterFile_Multi_Banked
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/include/Parameters.h

-              r81
+              r88
                         uint32_t    nb_port_write_by_bank,
                         Tcrossbar_t crossbar             );
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
+  public :        std::string   print      (uint32_t depth);
+  public : friend std::ostream& operator<< (std::ostream& output_stream,
+                                            morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters & x);
+  public :        std::string     print      (uint32_t depth);
+  public : friend std::ostream&   operator<< (std::ostream& output_stream,
+                                              morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters & x);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/include/RegisterFile_Multi_Banked.h

-              r82
+              r88
   public  :          ~RegisterFile_Multi_Banked             (void);
-#ifdef SYSTEMC
   private : void     allocation                (void);
   private : void     deallocation              (void);
+#ifdef SYSTEMC
   private : Taddress_t address_bank                 (Taddress_t address);
   private : Taddress_t address_num_reg              (Taddress_t address);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/src/Parameters.cpp

-              r81
+              r88
   };
   Parameters::Parameters (Parameters & param):
     _nb_port_read          (param._nb_port_read         ),
     _nb_port_write         (param._nb_port_write        ),
     _nb_word               (param._nb_word              ),
     _size_word             (param._size_word            ),
     _nb_bank               (param._nb_bank              ),
     _nb_port_read_by_bank  (param._nb_port_read_by_bank ),
     _nb_port_write_by_bank (param._nb_port_write_by_bank),
     _crossbar              (param._crossbar             ),
     _size_address          (param._size_address         ),
     _size_address_by_bank  (param._size_address_by_bank ),
     _bank_shift            (param._bank_shift           ),
     _bank_mask             (param._bank_mask            ),
     _num_reg_shift         (param._num_reg_shift        ),
     _num_reg_mask          (param._num_reg_mask         ),
     _nb_word_by_bank       (param._nb_word_by_bank      ),
     _have_port_address     (param._have_port_address     ),
     _have_bank_port_address(param._have_bank_port_address)
+  {
     log_printf(FUNC,RegisterFile_Multi_Banked,"Parameters (copy)","Begin");
+//   Parameters::Parameters (Parameters & param):
+//     _nb_port_read          (param._nb_port_read         ),
+//     _nb_port_write         (param._nb_port_write        ),
+//     _nb_word               (param._nb_word              ),
+//     _size_word             (param._size_word            ),
+//     _nb_bank               (param._nb_bank              ),
+//     _nb_port_read_by_bank  (param._nb_port_read_by_bank ),
+//     _nb_port_write_by_bank (param._nb_port_write_by_bank),
+//     _crossbar              (param._crossbar             ),
+//     _size_address          (param._size_address         ),
+//     _size_address_by_bank  (param._size_address_by_bank ),
+//     _bank_shift            (param._bank_shift           ),
+//     _bank_mask             (param._bank_mask            ),
+//     _num_reg_shift         (param._num_reg_shift        ),
+//     _num_reg_mask          (param._num_reg_mask         ),
+//     _nb_word_by_bank       (param._nb_word_by_bank      ),
+//     _have_port_address     (param._have_port_address     ),
+//     _have_bank_port_address(param._have_bank_port_address)
+//   {
+//     log_printf(FUNC,RegisterFile_Multi_Banked,"Parameters (copy)","Begin");
     if (_crossbar == PARTIAL_CROSSBAR)
+      {
         // All port_src is connected with one port_dest on each bank
+//     if (_crossbar == PARTIAL_CROSSBAR)
+//       {
+//      // All port_src is connected with one port_dest on each bank
         _link_port_read_to_bank_read     = new uint32_t [_nb_port_read ];
 //      _link_port_read_to_num_bank         = new uint32_t [_nb_port_read ];
         _link_port_write_to_bank_write   = new uint32_t [_nb_port_write];
 //      _link_port_write_to_num_bank        = new uint32_t [_nb_port_write];
+//      _link_port_read_to_bank_read     = new uint32_t [_nb_port_read ];
+// //   _link_port_read_to_num_bank         = new uint32_t [_nb_port_read ];
+//      _link_port_write_to_bank_write   = new uint32_t [_nb_port_write];
+// //   _link_port_write_to_num_bank        = new uint32_t [_nb_port_write];
         for (uint32_t i=0; i<_nb_port_read         ;i++)
+          {
             _link_port_read_to_bank_read   [i] = param._link_port_read_to_bank_read     [i];
 //          _link_port_read_to_num_bank       [i] = param._link_port_read_to_num_bank    [i];
+          }
         for (uint32_t i=0; i<_nb_port_write        ;i++)
+          {
             _link_port_write_to_bank_write [i] = param._link_port_write_to_bank_write    [i];
 //          _link_port_write_to_num_bank      [i] = param._link_port_write_to_num_bank   [i];
+          }
+      }
+//      for (uint32_t i=0; i<_nb_port_read         ;i++)
+//        {
+//          _link_port_read_to_bank_read   [i] = param._link_port_read_to_bank_read     [i];
+// //       _link_port_read_to_num_bank       [i] = param._link_port_read_to_num_bank    [i];
+//        }
+//      for (uint32_t i=0; i<_nb_port_write        ;i++)
+//        {
+//          _link_port_write_to_bank_write [i] = param._link_port_write_to_bank_write    [i];
+// //       _link_port_write_to_num_bank      [i] = param._link_port_write_to_num_bank   [i];
+//        }
+//       }
     test();
     log_printf(FUNC,RegisterFile_Multi_Banked,"Parameters (copy)","End");
   };
+//     test();
+//     log_printf(FUNC,RegisterFile_Multi_Banked,"Parameters (copy)","End");
+//   };
   Parameters::~Parameters ()
 …
   };
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,RegisterFile_Multi_Banked,"copy","Begin");
+    log_printf(FUNC,RegisterFile_Multi_Banked,"copy","End");
+  };
 }; // end namespace registerfile_multi_banked
 }; // end namespace registerfile

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/src/RegisterFile_Multi_Banked.cpp

-              r82
+              r88
 namespace registerfile_multi_banked {
+#undef  FUNCTION
+#define FUNCTION "RegisterFile_Multi_Banked::RegisterFile_Multi_Banked"
   RegisterFile_Multi_Banked::RegisterFile_Multi_Banked
+  (
 …
     ,_usage (usage)
+  {
     log_printf(FUNC,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","Begin");
+    log_printf(FUNC,RegisterFile_Multi_Banked,FUNCTION,"Begin");
 #ifdef SYSTEMC
     log_printf(INFO,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","Allocation");
+#if DEBUG_RegisterFile_Multi_Banked == true
+    log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
+    log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Allocation");
     allocation ();
-#endif
 #ifdef STATISTICS
+    log_printf(INFO,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","Allocation of statistics");
+    // Allocation of statistics
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Allocation of statistics");
+        // Allocation of statistics
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","Generate the vhdl");
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Generate the vhdl");
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // Function pointer
     if (_param->_crossbar == FULL_CROSSBAR)
 …
+      }
     log_printf(INFO,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","Method - transition");
+    log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Method - transition");
     SC_METHOD (transition);
 …
 #endif
     log_printf(INFO,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","Method - genMealy_write");
+    log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Method - genMealy_write");
     SC_METHOD (genMealy_read);
 …
+      }
 #endif
+      }
 #endif
     log_printf(FUNC,RegisterFile_Multi_Banked,"RegisterFile_Multi_Banked","End");
+    log_printf(FUNC,RegisterFile_Multi_Banked,FUNCTION,"End");
   };
+#undef  FUNCTION
+#define FUNCTION "RegisterFile_Multi_Banked::~RegisterFile_Multi_Banked"
   RegisterFile_Multi_Banked::~RegisterFile_Multi_Banked (void)
+  {
     log_printf(FUNC,RegisterFile_Multi_Banked,"~RegisterFile_Multi_Banked","Begin");
+    log_printf(FUNC,RegisterFile_Multi_Banked,FUNCTION,"Begin");
 #ifdef STATISTICS
+    log_printf(INFO,RegisterFile_Multi_Banked,"~RegisterFile_Multi_Banked","Generate Statistics file");
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Generate Statistics file");
+        delete _stat;
+      }
 #endif
+#ifdef SYSTEMC
     log_printf(INFO,RegisterFile_Multi_Banked,"~RegisterFile_Multi_Banked","Deallocation");
+    log_printf(INFO,RegisterFile_Multi_Banked,FUNCTION,"Deallocation");
+    deallocation ();
+    deallocation ();
+#endif
+    log_printf(FUNC,RegisterFile_Multi_Banked,"~RegisterFile_Multi_Banked","End");
+    log_printf(FUNC,RegisterFile_Multi_Banked,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/src/RegisterFile_Multi_Banked_allocation.cpp

-              r82
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       Interface * interface = _interfaces->set_interface(""
 …
      in_NRESET       = interface->set_signal_in  <Tcontrol_t> ("nreset",1, RESET_VHDL_YES);
     // ~~~~~[ Interface : "read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_READ_VAL         = new SC_IN (Tcontrol_t) * [_param->_nb_port_read];
 …
+      }
     // ~~~~~[ Interface : "write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      in_WRITE_VAL        = new SC_IN (Tcontrol_t) * [_param->_nb_port_write];
 …
+      }
+    // ~~~~~[ Registers ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+    // ~~~~~[ Registers ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     reg_DATA = new Tdata_t * [_param->_nb_bank];
 …
+      }
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     internal_WRITE_VAL     = new bool       [_param->_nb_port_write];
     internal_WRITE_BANK    = new Taddress_t [_param->_nb_port_write];
     internal_WRITE_NUM_REG = new Taddress_t [_param->_nb_port_write];
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/src/RegisterFile_Multi_Banked_deallocation.cpp

-              r81
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
     log_printf(FUNC,RegisterFile_Multi_Banked,"deallocation","Begin");
+    delete in_CLOCK;
+    delete in_NRESET;
+    // ----- Interface Read
+    delete []  in_READ_VAL    ;
+    delete [] out_READ_ACK    ;
+    if (_param->_have_port_address == true)
+    delete []  in_READ_ADDRESS;
+    delete [] out_READ_DATA   ;
+    // ----- Interface Write
+    delete []  in_WRITE_VAL    ;
+    delete [] out_WRITE_ACK    ;
+    if (_param->_have_port_address == true)
+    delete []  in_WRITE_ADDRESS;
+    delete []  in_WRITE_DATA   ;
+    // ----- Register
+    delete [] reg_DATA;
+    // ----- Internal
+    delete [] internal_WRITE_VAL;
+    delete [] internal_WRITE_BANK;
+    delete [] internal_WRITE_NUM_REG;
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
+        delete in_CLOCK;
+        delete in_NRESET;
+        // ----- Interface Read
+        delete []  in_READ_VAL    ;
+        delete [] out_READ_ACK    ;
+        if (_param->_have_port_address == true)
+        delete []  in_READ_ADDRESS;
+        delete [] out_READ_DATA   ;
+        // ----- Interface Write
+        delete []  in_WRITE_VAL    ;
+        delete [] out_WRITE_ACK    ;
+        if (_param->_have_port_address == true)
+        delete []  in_WRITE_ADDRESS;
+        delete []  in_WRITE_DATA   ;
+        // ----- Register
+        delete [] reg_DATA;
+        // ----- Internal
+        delete [] internal_WRITE_VAL;
+        delete [] internal_WRITE_BANK;
+        delete [] internal_WRITE_NUM_REG;
+      }
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked/src/RegisterFile_Multi_Banked_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/SelfTest/Makefile

r81	r88
24	24	library_clean : RegisterFile_library_clean
25	25
	26	local_clean :
	27
26	28	include ../Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/SelfTest/src/main.cpp

-              r81
+              r88
       if (instance == instance_RegisterFile_Monolithic)
+        {
+          morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters * param1 = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters (nb_port_read         ,
+                                                                                                                                                                                                nb_port_write        ,
+                    ,
+                                                                                                                                                                                                nb_word              ,
+                                                                                                                                                                                                size_word            );
+          morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters * param1 = new morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters
+            (nb_port_read         ,
+             nb_port_write        ,
+                    ,
+             nb_word              ,
+             size_word
+             );
           param = new morpheo::behavioural::generic::registerfile::Parameters(param1);
 …
       else
+        {
+          morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters * param2 = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters (nb_port_read         ,
+                                                                                                                                                                                                nb_port_write        ,
+                                                                                                                                                                                                nb_word              ,
+                                                                                                                                                                                                size_word            ,
+                                                                                                                                                                                                nb_bank              ,
+                                                                                                                                                                                                nb_port_read_by_bank ,
+                                                                                                                                                                                                nb_port_write_by_bank,
+                                                                                                                                                                                                crossbar             );
+          morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters * param2 = new morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters
+            (nb_port_read         ,
+             nb_port_write        ,
+             nb_word              ,
+             size_word            ,
+             nb_bank              ,
+             nb_port_read_by_bank ,
+             nb_port_write_by_bank,
+             crossbar
+             );
           param = new morpheo::behavioural::generic::registerfile::Parameters(param2);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   RegisterFile * _RegisterFile = new RegisterFile (name.c_str(),
 #ifdef STATISTICS
 …
 #endif
                                                    _param,
                                                    USE_ALL);
+                                                   _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/include/Parameters.h

-              r81
+              r88
   public : Parameters  (morpheo::behavioural::generic::registerfile::registerfile_monolithic  ::Parameters * param);
   public : Parameters  (morpheo::behavioural::generic::registerfile::registerfile_multi_banked::Parameters * param);
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void             copy       (void);
   public :        Parameters_test  msg_error  (void);
   public :        std::string   print      (uint32_t depth);
   public : friend std::ostream& operator<< (std::ostream& output_stream,

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/RegisterFile/src/Parameters.cpp

-              r81
+              r88
     _param_registerfile_monolithic   = param;
+    _param_registerfile_multi_banked = NULL;
     test();
 …
     log_printf(FUNC,RegisterFile,"Parameters","Begin");
+    _param_registerfile_monolithic   = NULL;
     _param_registerfile_multi_banked = param;
 …
   };
   Parameters::Parameters (Parameters & param):
     _instance          (param._instance     ),
     _nb_port_read      (param._nb_port_read ),
     _nb_port_write     (param._nb_port_write),
     _nb_word           (param._nb_word      ),
     _size_word         (param._size_word    ),
     _size_address      (param._size_address ),
     _have_port_address (param._have_port_address)
+  {
     log_printf(FUNC,RegisterFile,"Parameters (copy)","Begin");
+//   Parameters::Parameters (Parameters & param):
+//     _instance          (param._instance     ),
+//     _nb_port_read      (param._nb_port_read ),
+//     _nb_port_write     (param._nb_port_write),
+//     _nb_word           (param._nb_word      ),
+//     _size_word         (param._size_word    ),
+//     _size_address      (param._size_address ),
+//     _have_port_address (param._have_port_address)
+//   {
+//     log_printf(FUNC,RegisterFile,"Parameters (copy)","Begin");
     _param_registerfile_multi_banked = param._param_registerfile_multi_banked;
     _param_registerfile_monolithic   = param._param_registerfile_monolithic;
     test();
     log_printf(FUNC,RegisterFile,"Parameters (copy)","End");
   };
+//     _param_registerfile_multi_banked = param._param_registerfile_multi_banked;
+//     _param_registerfile_monolithic   = param._param_registerfile_monolithic;
+//     test();
+//     log_printf(FUNC,RegisterFile,"Parameters (copy)","End");
+//   };
   Parameters::~Parameters ()
 …
   };
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,RegisterFile,"copy","Begin");
+    throw ERRORMORPHEO("RegisterFile::copy",_("Invalid copy"));
+//     if (_instance == instance_RegisterFile_Monolithic)
+//       COPY(_param_registerfile_monolithic);
+//     if (_instance == instance_RegisterFile_Multi_Banked)
+//       COPY(_param_registerfile_multi_banked);
+    log_printf(FUNC,RegisterFile,"copy","End");
+  };
 }; // end namespace registerfile
 }; // end namespace generic

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/SelfTest/Makefile

r81	r88
23	23	library_clean : Select_Priority_Fixed_library_clean
24	24
	25	local_clean :
	26
25	27	include ../Makefile.deps
26	28	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/SelfTest/src/test.cpp

-              r82
+              r88
   cout << "<" << name << "> : Simulation SystemC" << endl;
 #ifdef STATISTICS
   morpheo::behavioural::Parameters_Statistics * _param_stat = new morpheo::behavioural::Parameters_Statistics (5,50);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Select_Priority_Fixed * _Select_Priority_Fixed = new Select_Priority_Fixed
     (name.c_str(),
 …
 #endif
      _param,
      USE_ALL);
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/include/Parameters.h

-              r81
+              r88
                         bool     encoding_one_hot,
                         bool     encoding_compact);
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string   print      (uint32_t depth);
   public : friend std::ostream& operator<< (std::ostream& output_stream,

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/include/Select_Priority_Fixed.h

-              r82
+              r88
   public  :          ~Select_Priority_Fixed             (void);
-#ifdef SYSTEMC
   private : void     allocation                (void);
   private : void     deallocation              (void);
+#ifdef SYSTEMC
 # if defined(STATISTICS) or defined(VHDL_TESTBENCH)
   public  : void     transition                (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Parameters.cpp

-              r81
+              r88
   };
   Parameters::Parameters (Parameters & param):
     _nb_entity        (param._nb_entity       ),
     _encoding_one_hot (param._encoding_one_hot),
     _encoding_compact (param._encoding_compact),
     _size_entity      (param._size_entity     )
+  {
     log_printf(FUNC,Select_Priority_Fixed,"Parameters","Begin");
     test();
     log_printf(FUNC,Select_Priority_Fixed,"Parameters","End");
   };
+//   Parameters::Parameters (Parameters & param):
+//     _nb_entity        (param._nb_entity       ),
+//     _encoding_one_hot (param._encoding_one_hot),
+//     _encoding_compact (param._encoding_compact),
+//     _size_entity      (param._size_entity     )
+//   {
+//     log_printf(FUNC,Select_Priority_Fixed,"Parameters","Begin");
+//     test();
+//     log_printf(FUNC,Select_Priority_Fixed,"Parameters","End");
+//   };
   Parameters::~Parameters ()
 …
     log_printf(FUNC,Select_Priority_Fixed,"~Parameters","Begin");
     log_printf(FUNC,Select_Priority_Fixed,"~Parameters","End");
+  };
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Select_Priority_Fixed,"copy","Begin");
+    log_printf(FUNC,Select_Priority_Fixed,"copy","End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed.cpp

-              r81
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
     log_printf(FUNC,Select_Priority_Fixed,"Select_Priority_Fixed","Begin");
+#if DEBUG_Select_Priority_Fixed == true
+    log_printf(INFO,Select_Priority_Fixed,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Allocation");
     allocation ();
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Allocation of statistics");
 …
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Generate the vhdl");
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL)
+      {
+        // generate the vhdl
+        log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Generate the vhdl");
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+      {
+      if (usage_is_set(_usage,USE_SYSTEMC))
+        {
 #  if defined(STATISTICS) or defined(VHDL_TESTBENCH)
         log_printf(INFO,Select_Priority_Fixed,"Select_Priority_Fixed","Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Select_Priority_Fixed,"~Select_Priority_Fixed","Generate Statistics file");
 …
 #endif
-#ifdef SYSTEMC
     log_printf(INFO,Select_Priority_Fixed,"~Select_Priority_Fixed","Deallocation");
     deallocation ();
-#endif
     log_printf(FUNC,Select_Priority_Fixed,"~Select_Priority_Fixed","End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_allocation.cpp

-              r81
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
     _interfaces = entity->set_interfaces();
     // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     Interface_fifo * interface = _interfaces->set_interface(""
 …
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_deallocation.cpp

-              r81
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
     log_printf(FUNC,Select_Priority_Fixed,"deallocation","Begin");
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         delete     in_CLOCK;
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Select/Select_Priority_Fixed/src/Select_Priority_Fixed_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/SelfTest/Makefile

r81	r88
23	23	library_clean : Shifter_library_clean
24	24
	25	local_clean :
	26
25	27	include ../Makefile.deps
26	28	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/SelfTest/src/test.cpp

-              r82
+              r88
   morpheo::behavioural::Parameters_Statistics * param_stat = new morpheo::behavioural::Parameters_Statistics(5,50);
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Shifter * _Shifter = new Shifter (name.c_str(),
 #ifdef STATISTICS
 …
 #endif
                                     &param,
                                     USE_ALL);
+                                    _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/include/Parameters.h

-              r82
+              r88
                         carry_t     carry               ,
                         bool        type_completion_bool = false);
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string     print      (uint32_t depth);
   public : friend std::ostream&   operator<< (std::ostream& output_stream,

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/include/Shifter.h

-              r82
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
 #endif
+  {
     // -----[ fields ]----------------------------------------------------
+    // -----[ fields ]----------------------------------------------------
     // Parameters
   protected : const std::string  _name;
 …
 #ifdef SYSTEMC
     // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Interface ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   public    : SC_CLOCK                      *  in_CLOCK             ;
   public    : SC_IN (Tcontrol_t)            *  in_NRESET            ;
 …
   public    : SC_OUT(Tdata_t)              ** out_SHIFTER_DATA      ;
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #endif
     // -----[ methods ]---------------------------------------------------
+    // -----[ methods ]---------------------------------------------------
 #ifdef SYSTEMC
 …
   public  :          ~Shifter             (void);
-#ifdef SYSTEMC
   private : void     allocation                (void);
   private : void     deallocation              (void);
+#ifdef SYSTEMC
 #if (defined(STATISTICS) || defined (VHDL_TESTBENCH))
   public  : void     transition                (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Parameters.cpp

-              r81
+              r88
   };
   Parameters::Parameters (Parameters & param):
     _size_data                   (param._size_data                   ),
     _nb_port                     (param._nb_port                     ),
     _shift_value                 (param._shift_value                 ),
     _rotate                      (param._rotate                      ),
     _direction                   (param._direction                   ),
     _carry                       (param._carry                       ),
     _size_data_completion        (param._size_data_completion        ),
     _type_completion_bool        (param._type_completion_bool        ),
+//   Parameters::Parameters (Parameters & param):
+//     _size_data                   (param._size_data                   ),
+//     _nb_port                     (param._nb_port                     ),
+//     _shift_value                 (param._shift_value                 ),
+//     _rotate                      (param._rotate                      ),
+//     _direction                   (param._direction                   ),
+//     _carry                       (param._carry                       ),
+//     _size_data_completion        (param._size_data_completion        ),
+//     _type_completion_bool        (param._type_completion_bool        ),
     _internal_direction          (param._internal_direction          ),
     _internal_type               (param._internal_type               ),
     _internal_carry              (param._internal_carry              ),
+//     _internal_direction          (param._internal_direction          ),
+//     _internal_type               (param._internal_type               ),
+//     _internal_carry              (param._internal_carry              ),
     _have_shift_logic_left       (param._have_shift_logic_left       ),
     _have_shift_logic_right      (param._have_shift_logic_right      ),
     _have_shift_logic            (param._have_shift_logic            ),
     _have_shift_arithmetic_left  (param._have_shift_arithmetic_left  ),
     _have_shift_arithmetic_right (param._have_shift_arithmetic_right ),
     _have_shift_arithmetic       (param._have_shift_arithmetic       ),
     _have_shift                  (param._have_shift                  ),
     _have_rotate_left            (param._have_rotate_left            ),
     _have_rotate_right           (param._have_rotate_right           ),
     _have_rotate                 (param._have_rotate                 ),
+//     _have_shift_logic_left       (param._have_shift_logic_left       ),
+//     _have_shift_logic_right      (param._have_shift_logic_right      ),
+//     _have_shift_logic            (param._have_shift_logic            ),
+//     _have_shift_arithmetic_left  (param._have_shift_arithmetic_left  ),
+//     _have_shift_arithmetic_right (param._have_shift_arithmetic_right ),
+//     _have_shift_arithmetic       (param._have_shift_arithmetic       ),
+//     _have_shift                  (param._have_shift                  ),
+//     _have_rotate_left            (param._have_rotate_left            ),
+//     _have_rotate_right           (param._have_rotate_right           ),
+//     _have_rotate                 (param._have_rotate                 ),
     _have_direction_left         (param._have_direction_left         ),
     _have_direction_right        (param._have_direction_right        )
+//     _have_direction_left         (param._have_direction_left         ),
+//     _have_direction_right        (param._have_direction_right        )
+//   {
+//     test();
+//   };
+  Parameters::~Parameters ()
+  {
-    test();
   };
+  Parameters::~Parameters ()
+  { };
+  void Parameters::copy (void)
+  {
+  };
 }; // end namespace shifter

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter.cpp

-              r82
+              r88
+#undef  FUNCTION
+#define FUNCTION "Shifter::Shifter"
   Shifter::Shifter (
 #ifdef SYSTEMC
 …
     ,_usage (usage)
+  {
+#ifdef SYSTEMC
+#if DEBUG_Shifter == true
+    log_printf(INFO,Shifter,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     allocation ();
-#endif
 #ifdef STATISTICS
+    // Allocation of statistics
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        // Allocation of statistics
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 #if (defined(STATISTICS) || defined (VHDL_TESTBENCH))
     SC_METHOD (transition);
 …
+      }
 #endif
+      }
 #endif
   };
+#undef  FUNCTION
+#define FUNCTION "Shifter::~Shifter"
   Shifter::~Shifter (void)
+  {
+#ifdef SYSTEMC
+    deallocation ();
+#ifdef STATISTICS
+    if (usage_is_set(_usage,USE_STATISTICS))
+      delete _stat;
 #endif
+#ifdef STATISTICS
+    delete _stat;
+#endif
+    deallocation ();
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_allocation.cpp

-              r82
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
            in_SHIFTER_COMPLETION [i] = interface->set_signal_in  <Tdata_t     > ("completion",_param->_size_data_completion);
           out_SHIFTER_DATA       [i] = interface->set_signal_out <Tdata_t     > ("data"      ,_param->_size_data);
+        }
+        }
+    }
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_deallocation.cpp

-              r82
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
   void Shifter::deallocation (void)
+  {
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
 #if (defined(STATISTICS) || defined (VHDL_TESTBENCH))
     delete     in_CLOCK;
 …
     delete []  in_SHIFTER_COMPLETION;
     delete [] out_SHIFTER_DATA      ;
+      }
     delete _component;
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Shifter/src/Shifter_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/SelfTest/Makefile

r81	r88
24	24	library_clean : Sort_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Sort * _Sort = new Sort (name.c_str(),
 #ifdef STATISTICS
 …
 #endif
                            _param,
                            USE_ALL);
+                           _usage);
 #ifdef SYSTEMC
 …
               tab [ptr]._val = false;
               LABEL("OUTPUT [%d] %d - %d",i, out_OUTPUT_VAL [i]->read(), out_OUTPUT_DATA [i]->read(), out_OUTPUT_INDEX [i]->read());
+              LABEL("OUTPUT [%d] %d %d - %d",i, out_OUTPUT_VAL [i]->read(), out_OUTPUT_DATA [i]->read(), out_OUTPUT_INDEX [i]->read());
               TEST(Tcontrol_t,out_OUTPUT_VAL   [i]->read(),find);

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/include/Parameters.h

r81	r88
42	42	public : ~Parameters () ;
43	43
	44	public : void copy (void);
	45
44	46	public : Parameters_test msg_error (void);
45	47

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/src/Parameters.cpp

-              r81
+              r88
   };
+#undef  FUNCTION
+#define FUNCTION "Sort::copy"
+  void Parameters::copy (void)
+  {
+    log_printf(FUNC,Sort,FUNCTION,"Begin");
+    log_printf(FUNC,Sort,FUNCTION,"End");
+  };
 }; // end namespace sort
 }; // end namespace generic

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/src/Sort.cpp

-              r81
+              r88
     log_printf(FUNC,Sort,FUNCTION,"Begin");
+#if DEBUG_Sort == true
+    log_printf(INFO,Sort,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(INFO,Sort,FUNCTION,"Allocation");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,Sort,FUNCTION,"Allocation of statistics");
 …
 #ifdef VHDL
     if (_usage & USE_VHDL)
+    if (usage_is_set(_usage,USE_VHDL))
+      {
         // generate the vhdl
 …
 #ifdef SYSTEMC
     if (_usage & USE_SYSTEMC)
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,Sort,FUNCTION,"Method - transition");
 …
 #ifdef STATISTICS
     if (_usage & USE_STATISTICS)
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
         statistics_deallocation();

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/src/Sort_allocation.cpp

-              r81
+              r88
 namespace generic {
 namespace sort {
 #undef  FUNCTION
 …
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSTION))
+      _component->generate_file();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/src/Sort_deallocation.cpp

r81	r88
20	20	log_printf(FUNC,Sort,FUNCTION,"Begin");
21	21
22		if (~~_usage & USE_SYSTEMC~~)
	22	if (usage_is_set(_usage,USE_SYSTEMC))
23	23	{
24	24	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Sort/src/Sort_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/SelfTest/Makefile

r81	r88
24	24	library_clean : Victim_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
   Victim * _Victim = new Victim (name.c_str(),
 #ifdef STATISTICS
 …
 #endif
                                  _param,
                                  USE_ALL);
+                                 _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/SelfTest/Makefile

r81	r88
23	23	library_clean : Victim_Pseudo_LRU_library_clean
24	24
	25	local_clean :
	26
25	27	include ../Makefile.deps
26	28	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/SelfTest/src/test.cpp

-              r82
+              r88
 #endif
+  Victim_Pseudo_LRU * _Victim_Pseudo_LRU = new Victim_Pseudo_LRU (name.c_str(),
+  Tusage_t _usage = USE_ALL;
+//   _usage = usage_unset(_usage,USE_SYSTEMC              );
+//   _usage = usage_unset(_usage,USE_VHDL                 );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
+//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
+//   _usage = usage_unset(_usage,USE_POSITION             );
+//   _usage = usage_unset(_usage,USE_STATISTICS           );
+//   _usage = usage_unset(_usage,USE_INFORMATION          );
+  Victim_Pseudo_LRU * _Victim_Pseudo_LRU = new Victim_Pseudo_LRU
+    (name.c_str(),
 #ifdef STATISTICS
                                                                   param_stat,
 #endif
                                                                   &param,
                                                                   USE_ALL);
+     param_stat,
+#endif
+     &param,
+     _usage);
 #ifdef SYSTEMC

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/include/Parameters.h

-              r81
+              r88
                         uint32_t size_table,
                         bool     table_global);
   public : Parameters  (Parameters & param) ;
+//   public : Parameters  (Parameters & param) ;
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string     print      (uint32_t depth);
   public : friend std::ostream&   operator<< (std::ostream& output_stream,

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/include/Victim_Pseudo_LRU.h

-              r82
+              r88
   public  :          ~Victim_Pseudo_LRU             (void);
-#ifdef SYSTEMC
   private : void     allocation                (void);
   private : void     deallocation              (void);
+#ifdef SYSTEMC
   public  : void     transition                (void);
   public  : void     genMoore                  (void);
+  public  : void     genMealy                  (void);
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Parameters.cpp

-              r81
+              r88
   };
+  Parameters::Parameters (Parameters & param):
+    _nb_entity  (param._nb_entity ),
+    _nb_access  (param._nb_access ),
+//     _nb_update  (param._nb_update ),
+    _size_table (param._size_table),
+    _table_global(param._table_global),
+    _size_address(param._size_address)
+  {
+    test();
+//   Parameters::Parameters (Parameters & param):
+//     _nb_entity  (param._nb_entity ),
+//     _nb_access  (param._nb_access ),
+// //     _nb_update  (param._nb_update ),
+//     _size_table (param._size_table),
+//     _table_global(param._table_global),
+//     _size_address(param._size_address)
+//   {
+//     test();
+//   };
+  Parameters::~Parameters ()
+  {
   };
+  Parameters::~Parameters ()
+  { };
+  void Parameters::copy (void)
+  {
+  };
 }; // end namespace victim_pseudo_lru

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU.cpp

-              r82
+              r88
     log_printf(FUNC,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Begin");
+#ifdef SYSTEMC
+#if DEBUG_Victim_Pseudo_LRU == true
+    log_printf(INFO,Victim_Pseudo_LRU,FUNCTION,_("<%s> Parameters"),_name.c_str());
+    std::cout << *param << std::endl;
+#endif
     log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Allocation");
     allocation ();
-#endif
 #ifdef STATISTICS
+    log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Allocation of statistics");
+    // Allocation of statistics
+    statistics_declaration(param_statistics);
+    if (usage_is_set(_usage,USE_STATISTICS))
+      {
+        log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Allocation of statistics");
+        // Allocation of statistics
+        statistics_declaration(param_statistics);
+      }
 #endif
 #ifdef VHDL
+    // generate the vhdl
+    log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Generation of VHDL");
+    vhdl();
+    if (usage_is_set(_usage,USE_VHDL))
+      {
+        // generate the vhdl
+        log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Generation of VHDL");
+        vhdl();
+      }
 #endif
 #ifdef SYSTEMC
+    log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Definition of sc_method");
+    SC_METHOD (transition);
+    dont_initialize ();
+    sensitive << (*(in_CLOCK)).pos();
+    SC_METHOD (genMoore);
+    dont_initialize ();
+    sensitive << (*(in_CLOCK)).neg();
+#ifdef SYSTEMCASS_SPECIFIC
+#endif
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // Constant - ack is always at one
     for (uint32_t i=0; i<_param->_nb_access; i++)
 …
+      }
+    log_printf(TRACE,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","Definition of sc_method");
+    SC_METHOD (transition);
+    dont_initialize ();
+    sensitive << (*(in_CLOCK)).pos();
+    SC_METHOD (genMealy);
+    dont_initialize ();
+    sensitive << (*(in_CLOCK)).neg();
+    for (uint32_t i=0; i<_param->_nb_access; i++)
+      if (_param->_size_table>1)
+        sensitive << (*(in_ACCESS_ADDRESS[i]));
+#ifdef SYSTEMCASS_SPECIFIC
+    if (_param->_size_table>1)
+      for (uint32_t i=0; i<_param->_nb_access; i++)
+        (*(out_ACCESS_VICTIM[i])) (*(in_ACCESS_ADDRESS[i]));
+#endif
+      }
 #endif
     log_printf(FUNC,Victim_Pseudo_LRU,"Victim_Pseudo_LRU","End");
 …
+  {
     log_printf(FUNC,Victim_Pseudo_LRU,"~Victim_Pseudo_LRU","Begin");
+#ifdef SYSTEMC
     deallocation ();
+#endif
 #ifdef STATISTICS
+    delete _stat;
+    if (usage_is_set(_usage,USE_STATISTICS))
+      delete _stat;
 #endif
     log_printf(FUNC,Victim_Pseudo_LRU,"~Victim_Pseudo_LRU","End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_allocation.cpp

-              r82
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
+    }
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     // -----[ Register ]---------------------------------------------------
     reg_TABLE = new entry_t *  [_param->_size_table];
 …
     internal_ACCESS_ACK    = new Tcontrol_t [_param->_nb_access];
     internal_ACCESS_VICTIM = new Tentity_t  [_param->_nb_access];
+      }
 #ifdef POSITION
+    _component->generate_file();
+    if (usage_is_set(_usage,USE_POSITION))
+      _component->generate_file();
 #endif
   };
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_deallocation.cpp

-              r81
+              r88
-#ifdef SYSTEMC
 /*
  * $Id$
 …
   void Victim_Pseudo_LRU::deallocation (void)
+  {
+    if (usage_is_set(_usage,USE_SYSTEMC))
+      {
     delete     in_CLOCK;
     delete     in_NRESET;
 …
     delete [] internal_ACCESS_ACK   ;
     delete [] internal_ACCESS_VICTIM;
+      }
     delete _component;
 …
 }; // end namespace behavioural
 }; // end namespace morpheo
-#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_end_cycle.cpp

-              r81
+              r88
 #ifdef STATISTICS
+    _stat->end_cycle();
+    if (usage_is_set(_usage,USE_STATISTICS))
+      _stat->end_cycle();
 #endif
 …
     // Evaluation before read the ouput signal
 //  sc_start(0);
+    _interfaces->testbench();
+    if (usage_is_set(_usage,USE_VHDL_TESTBENCH))
+      _interfaces->testbench();
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/Victim_Pseudo_LRU/src/Victim_Pseudo_LRU_genMealy.cpp

r87	r88
15	15	namespace victim_pseudo_lru {
16	16
17		void Victim_Pseudo_LRU::genM~~oore~~ (void)
	17	void Victim_Pseudo_LRU::genMealy (void)
18	18	{
19	19	for (uint32_t i=0; i<_param->_nb_access; i++)

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/include/Parameters.h

-              r81
+              r88
 namespace generic {
 namespace victim {
   class Parameters : public morpheo::behavioural::Parameters
 …
   public : ~Parameters () ;
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
 …
 }; // end namespace victim
 }; // end namespace generic
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/src/Parameters.cpp

-              r81
+              r88
     switch (_victim_scheme)
+      {
+//    case VICTIM_RANDOM      : delete _param_victim_random     ;
+//    case VICTIM_ROUND_ROBIN : delete _param_victim_round_robin;
+//    case VICTIM_NLU         : delete _param_victim_nlu        ;
+      case VICTIM_PSEUDO_LRU  : delete _param_victim_pseudo_lru ;
+//    case VICTIM_LRU         : delete _param_victim_lru        ;
+//    case VICTIM_FIFO        : delete _param_victim_fifo       ;
+//    case VICTIM_RANDOM      : delete _param_victim_random     ; break;
+//    case VICTIM_ROUND_ROBIN : delete _param_victim_round_robin; break;
+//    case VICTIM_NLU         : delete _param_victim_nlu        ; break;
+      case VICTIM_PSEUDO_LRU  : delete _param_victim_pseudo_lru ; break;
+//    case VICTIM_LRU         : delete _param_victim_lru        ; break;
+//    case VICTIM_FIFO        : delete _param_victim_fifo       ; break;
+      default : break;
+      }
+    log_printf(FUNC,Victim,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Victim::copy"
+  void morpheo::behavioural::generic::victim::Parameters::copy (void)
+  {
+    log_printf(FUNC,Victim,FUNCTION,"Begin");
+    switch (_victim_scheme)
+      {
+//    case VICTIM_RANDOM      : COPY(_param_victim_random     ); break;
+//    case VICTIM_ROUND_ROBIN : COPY(_param_victim_round_robin); break;
+//    case VICTIM_NLU         : COPY(_param_victim_nlu        ); break;
+      case VICTIM_PSEUDO_LRU  : COPY(_param_victim_pseudo_lru ); break;
+//    case VICTIM_LRU         : COPY(_param_victim_lru        ); break;
+//    case VICTIM_FIFO        : COPY(_param_victim_fifo       ); break;
       default : break;
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/src/Parameters_msg_error.cpp

-              r81
+              r88
     switch (_victim_scheme)
+      {
       case VICTIM_RANDOM      : test.error("Victim scheme '"+toString(_victim_scheme)+"' is not supported. (Coming Soon)"); break;
       case VICTIM_ROUND_ROBIN : test.error("Victim scheme '"+toString(_victim_scheme)+"' is not supported. (Coming Soon)"); break;
       case VICTIM_NLU         : test.error("Victim scheme '"+toString(_victim_scheme)+"' is not supported. (Coming Soon)"); break;
 //    case VICTIM_PSEUDO_LRU  : test.error("Victim scheme '"+toString(_victim_scheme)+"' is not supported. (Coming Soon)"); break;
       case VICTIM_LRU         : test.error("Victim scheme '"+toString(_victim_scheme)+"' is not supported. (Coming Soon)"); break;
       case VICTIM_FIFO        : test.error("Victim scheme '"+toString(_victim_scheme)+"' is not supported. (Coming Soon)"); break;
+      case VICTIM_RANDOM      : test.error(toString(_("Victim scheme \"%s\" is not supported. (Coming Soon)\n"),toString(_victim_scheme).c_str())); break;
+      case VICTIM_ROUND_ROBIN : test.error(toString(_("Victim scheme \"%s\" is not supported. (Coming Soon)\n"),toString(_victim_scheme).c_str())); break;
+      case VICTIM_NLU         : test.error(toString(_("Victim scheme \"%s\" is not supported. (Coming Soon)\n"),toString(_victim_scheme).c_str())); break;
+//    case VICTIM_PSEUDO_LRU  : test.error(toString(_("Victim scheme \"%s\" is not supported. (Coming Soon)\n"),toString(_victim_scheme).c_str())); break;
+      case VICTIM_LRU         : test.error(toString(_("Victim scheme \"%s\" is not supported. (Coming Soon)\n"),toString(_victim_scheme).c_str())); break;
+      case VICTIM_FIFO        : test.error(toString(_("Victim scheme \"%s\" is not supported. (Coming Soon)\n"),toString(_victim_scheme).c_str())); break;
       default : break;
+      }

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/src/Victim.cpp

-              r81
+              r88
     allocation (
 #ifdef STATISTICS
                 param_statistics
+                param_statistics
 #endif
                 );
+                );
 #ifdef STATISTICS
+    if (_usage & USE_STATISTICS)
+      {
+        switch (_param->_victim_scheme)
+          {
+//        case VICTIM_RANDOM      : _stat = _component_victim_random      ->_stat; break;
+//        case VICTIM_ROUND_ROBIN : _stat = _component_victim_round_robin ->_stat; break;
+//        case VICTIM_NLU         : _stat = _component_victim_nlu         ->_stat; break;
+          case VICTIM_PSEUDO_LRU  : _stat = _component_victim_pseudo_lru  ->_stat; break;
+//        case VICTIM_LRU         : _stat = _component_victim_lru         ->_stat; break;
+//        case VICTIM_FIFO        : _stat = _component_victim_fifo        ->_stat; break;
+          default : break;
+          }
+    switch (_param->_victim_scheme)
+      {
+//    case VICTIM_RANDOM      : _stat = _component_victim_random      ->_stat; break;
+//    case VICTIM_ROUND_ROBIN : _stat = _component_victim_round_robin ->_stat; break;
+//    case VICTIM_NLU         : _stat = _component_victim_nlu         ->_stat; break;
+      case VICTIM_PSEUDO_LRU  : _stat = _component_victim_pseudo_lru  ->_stat; break;
+//    case VICTIM_LRU         : _stat = _component_victim_lru         ->_stat; break;
+//    case VICTIM_FIFO        : _stat = _component_victim_fifo        ->_stat; break;
+      default : break;
+      }
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/Generic/Victim/src/Victim_deallocation.cpp

r81	r88
32	32	}
33	33
34		if (~~_usage & USE_SYSTEMC~~)
	34	if (usage_is_set(_usage,USE_SYSTEMC))
35	35	{
36	36	delete in_CLOCK ;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Common

-              r85
+              r88
+#
+include                         $(MORPHEO_TOPLEVEL)/Makefile.tools
+ifeq ($(origin MORPHEO_TOPLEVEL), undefined)
+        $(error "variable MORPHEO_TOPLEVEL is undefined");
+else
+        include                         $(MORPHEO_TOPLEVEL)/Makefile.tools
+endif
+ifeq ($(origin MORPHEO_TMP), undefined)
+        $(error "variable MORPHEO_TMP      is undefined");
+endif
+ifeq ($(origin MORPHEO_SCRIPT), undefined)
+        $(error "variable MORPHEO_SCRIPT   is undefined");
+endif
+ifeq ($(origin DIR_MORPHEO), undefined)
+        $(error "variable DIR_MORPHEO      is undefined");
+endif
 #-----[ Directory ]----------------------------------------
+DIR_TMP                         = $(MORPHEO_TMP)
 DIR_INC                         = include
 DIR_SRC                         = src
 DIR_OBJ                         = obj
+#DIR_LIB                                = $(DIR_TMP)/lib
 DIR_SCRIPT                      = $(MORPHEO_SCRIPT)
 …
 #-----[ Variable ]-----------------------------------------
+ENTITY                          = `$(BASENAME) $$PWD`
+ENTITY                          = $$($(BASENAME) $$PWD)
 OBJECTS_COMMON                  = $(patsubst $(DIR_SRC)/%.cpp,$(DIR_OBJ)/%.o,$(wildcard $(DIR_SRC)/*.cpp))
 …
 test_env                        :
-ifeq ($(origin MORPHEO_TOPLEVEL), undefined)
-                                $(error "variable MORPHEO_TOPLEVEL is undefined");
-endif
-ifeq ($(origin MORPHEO_SCRIPT), undefined)
-                                $(error "variable MORPHEO_SCRIPT   is undefined");
-endif
-ifeq ($(origin DIR_MORPHEO), undefined)
-                                $(error "variable DIR_MORPHEO      is undefined");
-endif
                                 @$(ECHO) "-------------------| $(ENTITY)"
 …
                                         $(DIR_INC)/*~;
+common_clean_all                : common_clean
 common_help                     :
                                 @\

trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Component

-              r81
+              r88
 #-----[ Directory ]----------------------------------------
 DIR_DOC                         = doc
-DIR_LIB                         = lib
 DIR_TEST                        = SelfTest
+DIR_LIB                         = lib
 #-----[ Variable ]-----------------------------------------
 …
 component_clean                 :
                                 @$(RM) $(DIR_LIB)
+#                               if $(TEST) -d $(DIR_DOC); then $(MAKE) --directory=$(DIR_DOC) --makefile=Makefile clean; fi;
+component_clean_all             : component_clean
+#                               if $(TEST) -d $(DIR_DOC); then $(MAKE) --directory=$(DIR_DOC) --makefile=Makefile clean_all; fi;
 component_help                  :
 …
                                 @\
                                 $(MAKE) common_clean ;\
+                                $(MAKE) component_clean;\
+                                if $(TEST) -d $(DIR_DOC); then $(MAKE) --directory=$(DIR_DOC) --makefile=Makefile clean; fi;
+                                $(MAKE) component_clean;
+clean_all                               :
+                                @\
+                                $(MAKE) common_clean_all ;\
+                                $(MAKE) component_clean_all;

trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Documentation

-              r81
+              r88
 #-----[ Directory ]----------------------------------------
+#-----[ Directory ]----------------------------------------
+DIR_DOCUMENTATION       = .
+DIR_TEX                 = $(DIR_DOCUMENTATION)
+DIR_SCHEMA              = $(DIR_DOCUMENTATION)/fig
+DIR_SCHEMA_EPS          = $(DIR_DOCUMENTATION)/eps
+DIR_DOC                 = .
+DIR_TEX                 = $(DIR_DOC)
+DIR_FIG                 = $(DIR_DOC)/fig
+DIR_EPS                 = $(DIR_DOC)/eps
+DIR_STY                 = $(DIR_DOC)/sty
 #-----[ Files ]--------------------------------------------
+#-----[ Files ]--------------------------------------------
 TEX_FILES               = $(wildcard $(DIR_TEX)/*.tex)
 …
 PS_FILES                = $(patsubst $(DIR_TEX)/%.tex,%.ps ,$(TEX_FILES))
 PDF_FILES               = $(patsubst $(DIR_TEX)/%.tex,%.pdf,$(TEX_FILES))
+EPS_FILES               = $(patsubst $(DIR_SCHEMA)/%.fig,$(DIR_SCHEMA_EPS)/%.eps,$(wildcard $(DIR_SCHEMA)/*.fig))       \
+                          $(patsubst $(DIR_SCHEMA)/%.eps,$(DIR_SCHEMA_EPS)/%.eps,$(wildcard $(DIR_SCHEMA)/*.eps))
+EPS_FILES               = $(patsubst $(DIR_FIG)/%.fig,$(DIR_EPS)/%.eps,$(wildcard $(DIR_FIG)/*.fig))       \
+                          $(patsubst $(DIR_FIG)/%.dot,$(DIR_EPS)/%.eps,$(wildcard $(DIR_FIG)/*.dot))       \
+                          $(patsubst $(DIR_FIG)/%.eps,$(DIR_EPS)/%.eps,$(wildcard $(DIR_FIG)/*.eps))
 #-----[ Rules ]--------------------------------------------
+#-----[ Rules ]--------------------------------------------
 #--------------------------------------------------------------------------------
 # The reset of this file shall not be editted
 #--------------------------------------------------------------------------------
 .PHONY                  : all clean help
 .SECONDARY              : $(DVI_FILES) $(PS_FILES) $(PDF_FILES) $(EPS_FILES) $(DIR_SCHEMA_EPS)
+.PHONY                  : all clean clean_all help
+.SECONDARY              : $(DVI_FILES) $(PS_FILES) $(PDF_FILES) $(EPS_FILES) $(DIR_EPS)
 all_documentation       : $(EPS_FILES)
+all_documentation       : $(EPS_FILES)
                         $(MAKE) $(PDF_FILES)
 …
 # regular flow tex -> dvi -> ps -> pdf.
 #--------------------------------------------------------------------------------
 %.pdf                   : %.ps
+%.pdf                   : %.ps
                         @\
                         $(ECHO) "Génération du fichier $*.pdf";         \
+                        $(ECHO) "Génération du fichier $*.pdf";         \
                         $(PS2PDF) $< $@;
 %.ps                    : %.dvi
+%.ps                    : %.dvi
                         @\
                         $(ECHO) "Génération du fichier $*.ps";          \
+                        $(ECHO) "Génération du fichier $*.ps";          \
                         $(DVIPS) -o $@ $<;
 %.dvi                   : $(DIR_TEX)/%.tex
+%.dvi                   : $(DIR_TEX)/%.tex
                         @\
                         $(ECHO) "Génération du fichier $*.dvi";         \
                         $(LATEX) $<;                                    \
                         $(LATEX) $< > /dev/null;                        \
                         citation=`$(GREP) "citation" $*.aux`;           \
                         if $(TEST) -n "$$citation" ; then               \
                                 $(BIBTEX) $* ;                          \
                         fi;                                             \
                         $(LATEX) $< > /dev/null;                        \
+                        $(ECHO) "Génération du fichier $*.dvi";         \
+                        $(LATEX) $<;                                    \
+                        $(LATEX) $< > /dev/null;                        \
+                        citation=`$(GREP) "citation" $*.aux`;           \
+                        if $(TEST) -n "$$citation" ; then               \
+                                $(BIBTEX) $* ;                          \
+                        fi;                                             \
+                        $(LATEX) $< > /dev/null;                        \
                         $(LATEX) $< > /dev/null;
 …
 # The figures directory
 #--------------------------------------------------------------------------------
 $(DIR_SCHEMA_EPS)       :
+$(DIR_EPS)      :
                         @\
                         $(ECHO) "Make directory       : $@";            \
+                        $(ECHO) "Make directory       : $@";            \
                         $(MKDIR) $@;
 $(DIR_SCHEMA_EPS)/%.eps : $(DIR_SCHEMA)/%.eps $(DIR_SCHEMA_EPS)
+$(DIR_EPS)/%.eps        : $(DIR_FIG)/%.eps $(DIR_EPS)
                         @\
                         $(ECHO) "Generate   files     : $*.eps";        \
                         $(CP) $(DIR_SCHEMA)/$*.eps $(DIR_SCHEMA_EPS);
+                        $(ECHO) "Generate   files     : $*.eps";        \
+                        $(CP) $(DIR_FIG)/$*.eps $(DIR_EPS);
 $(DIR_SCHEMA_EPS)/%.eps : $(DIR_SCHEMA)/%.fig $(DIR_SCHEMA_EPS)
+$(DIR_EPS)/%.eps        : $(DIR_FIG)/%.fig $(DIR_EPS)
                         @\
                         $(ECHO) "Generate   files     : $*.eps";        \
+                        $(ECHO) "Generate   files     : $*.eps";        \
                         $(FIG2EPS) $< $@;
+$(DIR_EPS)/%.eps        : $(DIR_FIG)/%.dot $(DIR_EPS)
+                        @\
+                        $(ECHO) "Generate   files     : $*.eps";        \
+                        $(DOT) -Tfig -o $(DIR_EPS)/${*}.fig $<; \
+                        $(FIG2EPS) $(DIR_EPS)/${*}.fig $@;      \
+                        $(RM) $(DIR_EPS)/${*}.fig;
 #--------------------------------------------------------------------------------
 …
 #--------------------------------------------------------------------------------
 clean                   :
+clean                   :
                         @\
                         $(ECHO) "Delete     temporary files              "$(PWD); \
+                        $(RM) $(DIR_SCHEMA_EPS);                        \
+                        $(RM) $(DVI_FILES) $(PS_FILES) $(PDF_FILES);    \
+                        $(MAKE) clean_rec DIR_CLEAN=.;
+                        $(RM) $(DIR_EPS)                      \
+                              $(DVI_FILES)                    \
+                              $(PS_FILES)                     \
+                              $(DIR_DOC)/*~                   \
+                              $(DIR_STY)/*~                   \
+                              $(DIR_TEX)/*~                   \
+                              $(DIR_FIG)/*~                   \
+                              $(DIR_DOC)/*.bak                \
+                              $(DIR_DOC)/*.aux                \
+                              $(DIR_DOC)/*.bbl                \
+                              $(DIR_DOC)/*.blg                \
+                              $(DIR_DOC)/*.bmt                \
+                              $(DIR_DOC)/*.log                \
+                              $(DIR_DOC)/*.mtc*               \
+                              $(DIR_DOC)/*.toc                \
+                              $(DIR_DOC)/*.idx                \
+                              $(DIR_DOC)/*.maf                \
+                              $(DIR_DOC)/*.ilg                \
+                              $(DIR_DOC)/*.ind                \
+                              $(DIR_DOC)/*.out                \
+                              $(DIR_DOC)/*.nav                \
+                              $(DIR_DOC)/*.snm                \
+                              $(DIR_DOC)/missfont.log;        \
+#Clean recursive
+clean_rec               :
+                        @\
+                        $(ECHO) "Delete     temporary files in directory $(DIR_CLEAN)"; \
+                        $(RM)   $(DIR_CLEAN)/*~                 \
+                                $(DIR_CLEAN)/*.bak              \
+                                $(DIR_CLEAN)/*.aux              \
+                                $(DIR_CLEAN)/*.bbl              \
+                                $(DIR_CLEAN)/*.blg              \
+                                $(DIR_CLEAN)/*.bmt              \
+                                $(DIR_CLEAN)/*.log              \
+                                $(DIR_CLEAN)/*.mtc*             \
+                                $(DIR_CLEAN)/*.toc              \
+                                $(DIR_CLEAN)/*.idx              \
+                                $(DIR_CLEAN)/*.ilg              \
+                                $(DIR_CLEAN)/*.ind              \
+                                $(DIR_CLEAN)/*.out              \
+                                $(DIR_CLEAN)/*.nav              \
+                                $(DIR_CLEAN)/*.snm              \
+                                $(DIR_CLEAN)/missfont.log;      \
+                        for files in `$(LS) $(DIR_CLEAN)`; do                                                   \
+                                if $(TEST) -d $(DIR_CLEAN)/$$files;                                             \
+                                then                                                                            \
+                                        $(MAKE) clean_rec DIR_CLEAN=$(DIR_CLEAN)/$$files;                       \
+                                fi;                                                                             \
+                        done;
+clean_all               : clean
+                        @$(RM) $(PDF_FILES);
 #--------------------------------------------------------------------------------
 …
 #--------------------------------------------------------------------------------
 help                    :
+help                    :
                         @\
+                        $(ECHO) " -----[ Documentation ]------------------------------";\
+                        $(ECHO) "";                                                     \
+                        $(ECHO) " * all_documentation    : Generate all documents";     \
+                        $(ECHO) " * clean                : Erase all generate files";   \
+                        $(ECHO) " * help                 : Print this message";         \
+                        $(ECHO) " -----[ Documentation ]------------------------------";\
+                        $(ECHO) "";                                                     \
+                        $(ECHO) " * all_documentation    : Generate all documents";     \
+                        $(ECHO) " * clean                : Erase all temporary files";  \
+                        $(ECHO) " * clean_all            : Erase all generate files";   \
+                        $(ECHO) " * help                 : Print this message";         \
                         $(ECHO) "";

trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Selftest

-              r83
+              r88
 #-----[ Directory ]----------------------------------------
 DIR_BIN                         = bin
 DIR_LIB                         = ../lib
 DIR_CFG_GEN                     = configuration_generated
+DIR_BIN                         = $(DIR_TMP)/bin
+DIR_LIB                         = ../lib
+DIR_CFG_GEN                     = $(DIR_TMP)/configuration_generated
 DIR_CFG_USER                    = configuration
 DIR_LOG                         = log
 …
                                 @\
                                 $(MAKE) library;\
                                 $(MAKE) $(DIR_BIN)/$(EXEC).x;
 execute                         : all_selftest
+                                $(MAKE) $(DIR_BIN)/$(EXEC).x;
+execute_only                    :
                                 @\
                                 $(MAKE) $(EXEC_LOG);                                    \
 …
                                     $(GREP) -q "Test KO" $$i;                           \
                                     declare -i test_ko=$$?;                             \
+                                    if $(TEST) $$test_ko -eq 0 -o $$test_ok -ne 0;      \
+                                    $(GREP) -q "ERROR" $$i;                             \
+                                    declare -i test_error=$$?;                          \
+                                    if $(TEST) $$test_ko -eq 0 -o $$test_error -eq 0 -o $$test_ok -ne 0; \
                                     then all_ok=0;                                      \
                                     fi;                                                 \
 …
                                 fi;
+execute                         : all_selftest
+                                @\
+                                $(MAKE) execute_only;
 reconfig                        :
                                 @\
 …
                                 fi;                                                                                                     \
+                                                                                                                                        \
+                                for file in $$files; do                                                                                 \
+                                                                                                                                        \
+                                declare -i NB_CONFIG=0;                                                                                 \
+                                declare -i NB_DIGIT=0;                                                                                  \
+                                                                                                                                        \
+                                for file in $${files}; do                                                                               \
+                                        declare -ai PERIOD=();                                                                          \
+                                        declare -i  IT=0;                                                                               \
+                                                                                                                                        \
+                                        PERIOD[0]=1;                                                                                    \
+                                                                                                                                        \
+                                        while read line; do                                                                             \
+                                                declare -a LINE=($${line});                                                             \
+                                                                                                                                        \
+                                                if $(TEST) $${IT} -ne 0; then                                                           \
+                                                        declare -a RANGE_LOCAL=($$($(DIR_SCRIPT)/range.sh $${LINE[0]} $${LINE[1]} $${LINE[2]}));        \
+                                                        declare -i SIZE=$${#RANGE_LOCAL[*]};                                            \
+                                                        PERIOD[$${IT}]=$$(($${PERIOD[$$(($${IT}-1))]}*$${SIZE}));                       \
+                                                fi;                                                                                     \
+                                                                                                                                        \
+                                                IT=$$(($${IT}+1));                                                                      \
+                                        done < $${file};                                                                                \
+                                                                                                                                        \
+                                        NB_CONFIG=$$(($${NB_CONFIG} + $${PERIOD[$$(($${IT}-1))]}));                                     \
+                                done;                                                                                                   \
+                                                                                                                                        \
+                                $(ECHO) " * They are $${NB_CONFIG} configurations";                                                     \
+                                                                                                                                        \
+                                declare -i x=$${NB_CONFIG};                                                                             \
+                                                                                                                                        \
+                                while test $${x} -ne 0; do                                                                              \
+                                        NB_DIGIT=$$(($${NB_DIGIT} + 1));                                                                \
+                                        x=$$(($${x} / 10));                                                                             \
+                                done;                                                                                                   \
+                                                                                                                                        \
+                                for file in $${files}; do                                                                               \
                                         declare     NAME;                                                                               \
+                                        declare -ai MIN ;                                                                               \
+                                        declare -ai MAX ;                                                                               \
+                                        declare -a  STEP;                                                                               \
+                                        declare -a  LINE;                                                                               \
+                                        declare -ai PERIOD;                                                                             \
+                                        declare -a  RANGE;                                                                              \
+                                        declare -a  RANGE_LOCAL;                                                                        \
+                                        declare -a  SIZE;                                                                               \
+                                        declare -ai MIN=();                                                                             \
+                                        declare -ai PERIOD=();                                                                          \
+                                        declare -a  RANGE_LOCAL=();                                                                     \
+                                        declare -a  RANGE=();                                                                           \
+                                        declare -a  SIZE=();                                                                            \
                                         declare -i  IT=0;                                                                               \
+                                                                                                                                        \
 …
+                                                                                                                                        \
                                         while read line; do                                                                             \
                                                 LINE=($$line);                                                                          \
+                                                                                                                                        \
                                                 if $(TEST) $$IT -eq 0; then                                                             \
+                                                declare -a LINE=($${line});                                                             \
+                                                                                                                                        \
+                                                if $(TEST) $${IT} -eq 0; then                                                           \
                                                         NAME=$${LINE[0]};                                                               \
                                                 else                                                                                    \
+                                                        MIN[$$IT]=$${LINE[0]};                                                          \
+                                                        MAX[$$IT]=$${LINE[1]};                                                          \
+                                                        STEP[$$IT]=$${LINE[2]};                                                         \
+                                                        RANGE[$$IT]=$$($(DIR_SCRIPT)/range.sh $${LINE[0]} $${LINE[1]} $${LINE[2]});     \
+                                                        RANGE_LOCAL=($${RANGE[$$IT]});                                                  \
+                                                        SIZE[$$IT]=$${#RANGE_LOCAL[*]};                                                 \
+                                                        PERIOD[$$IT]=$$(($${PERIOD[$$(($$IT-1))]}*$${SIZE[$$IT]}));                     \
+                                                        MIN[$${IT}]=$${LINE[0]};                                                        \
+                                                        RANGE[$${IT}]=$$($(DIR_SCRIPT)/range.sh $${LINE[0]} $${LINE[1]} $${LINE[2]});   \
+                                                        RANGE_LOCAL=($${RANGE[$${IT}]});                                                \
+                                                        SIZE[$${IT}]=$${#RANGE_LOCAL[*]};                                               \
+                                                        PERIOD[$${IT}]=$$(($${PERIOD[$$(($${IT}-1))]}*$${SIZE[$${IT}]}));               \
                                                 fi;                                                                                     \
+                                                                                                                                        \
+                                                IT=$$(($$IT+1));                                                                        \
+                                        done < $$file;                                                                                  \
+                                                                                                                                        \
+                                        declare -i x;                                                                                   \
+                                        declare -a DATA;                                                                                \
+                                        declare -ai ENUM_CONFIG=($$($(DIR_SCRIPT)/range.sh 0 $$(($${PERIOD[$$(($$IT-1))]}-1))));        \
+                                                IT=$$(($${IT}+1));                                                                      \
+                                        done < $${file};                                                                                \
+                                                                                                                                        \
+                                        declare -a  DATA=();                                                                            \
+                                        declare -ai ENUM_CONFIG=($$($(DIR_SCRIPT)/range.sh 0 $$(($${PERIOD[$$(($${IT}-1))]}-1))));      \
                                         declare -ai ENUM_PARAM=($$($(DIR_SCRIPT)/range.sh 1 $${#MIN[*]}));                              \
+                                        declare -i  NB_PARAM=$${#MIN[*]};                                                               \
+                                                                                                                                        \
                                         $(ECHO) " * File : $$file";                                                                     \
                                         $(ECHO) "   * They are $${#MIN[*]} parameters";                                                 \
                                         $(ECHO) "   * Generate $${PERIOD[$$(($$IT-1))]} configurations";                                \
+                                        $(ECHO) "   * They are $${NB_PARAM} parameters";                                                \
+                                        $(ECHO) "   * Generate $${PERIOD[$$(($${IT}-1))]} configurations";                              \
+                                                                                                                                        \
                                         for i in $${ENUM_CONFIG[*]}; do                                                                 \
                                                 x=$$i;                                                                                  \
                                                 for j in $${ENUM_PARAM[*]}; do                                                          \
                                                         RANGE_LOCAL=($${RANGE[$$j]});                                                   \
+                                                        declare -a RANGE_LOCAL=($${RANGE[$$j]});                                                        \
                                                         DATA[$$j]="$${RANGE_LOCAL[$$((($$x % $${SIZE[$$j]})))]} ";                      \
                                                         x=$$(($$x/$${SIZE[$$j]}));                                                      \
                                                 done;                                                                                   \
+                                                $(ECHO) $${DATA[*]} > "$(DIR_CFG_GEN)/$${NAME}_$$CPT.cfg";                              \
+                                                $(ECHO) "   - {$$CPT} $${DATA[*]}";                                                     \
+                                                CPT=$$(($$CPT+1));                                                                      \
+                                                declare NUM=$$($(PRINTF) %.$${NB_DIGIT}d $${CPT});                                      \
+                                                $(ECHO) $${DATA[*]} > "$(DIR_CFG_GEN)/$${NAME}_$${NUM}.cfg";                            \
+                                                $(ECHO) "   - {$${NUM}} $${DATA[*]}";                                                   \
+                                                CPT=$$(($${CPT}+1));                                                                    \
                                         done;                                                                                           \
                                 done;
 …
                                 @\
                                 $(ECHO) "Execute            : $*";\
                                 export SYSTEMC=$(SYSTEMC_$(SIMULATOR)) ; $(EXEC_PREFIX) ./$(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@; \
+                                export SYSTEMC=$(SYSTEMC_$(SIMULATOR)); $(EXEC_PREFIX) $(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@; \
                                 declare timing=`$(GREP) -h "Timing"  $@`;               \
                                 $(GREP) -q "Test OK" $@;                                \
 …
                                 $(GREP) -q "Test KO" $@;                                \
                                 declare -i test_ko=$$?;                                 \
+                                if $(TEST) $$test_ko -ne 0 -a $$test_ok -eq 0;          \
+                                $(GREP) -q "ERROR" $@;                                  \
+                                declare -i test_error=$$?;                              \
+                                if $(TEST) $$test_ko -ne 0 -a $$test_error -ne 0 -a $$test_ok -eq 0; \
                                 then echo -e "                     $* ... OK\t$$timing";\
                                 else echo    "                     $* ... KO";          \
 …
                                 @\
                                 $(ECHO) "Execute            : $*";\
                                 export SYSTEMC=$(SYSTEMC_$(SIMULATOR)) ; $(EXEC_PREFIX) ./$(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@; \
+                                export SYSTEMC=$(SYSTEMC_$(SIMULATOR)); $(EXEC_PREFIX) $(DIR_BIN)/$(EXEC).x $(EXEC_PARAMS) $* `$(CAT) $<` &> $@; \
                                 declare timing=`$(GREP) -h "Timing"  $@`;               \
                                 $(GREP) -q "Test OK" $@;                                \
 …
                                 $(GREP) -q "Test KO" $@;                                \
                                 declare -i test_ko=$$?;                                 \
+                                if $(TEST) $$test_ko -ne 0 -a $$test_ok -eq 0;          \
+                                then echo -e "                     $* ... OK\t$$timing";\
+                                else echo    "                     $* ... KO";          \
+                                $(GREP) -q "ERROR" $@;                                  \
+                                declare -i test_error=$$?;                              \
+                                if $(TEST) $$test_ko -ne 0 -a $$test_error -ne 0 -a $$test_ok -eq 0; \
+                                then $(ECHO) -e "                     $* ... OK\t$$timing";\
+                                else $(ECHO)    "                     $* ... KO";          \
                                 fi;
 …
                                 $(CXX) $(LFLAGS) -o $@ $(OBJECTS) $(LIBS);
+$(DIR_LIB)                      :
+                                @\
+                                $(ECHO) "Create directory   : $@";\
+                                $(MKDIR) $@;
 $(DIR_BIN)                      :
                                 @\
 …
                                 $(MKDIR) $@;
+selftest_clean_all              : library_clean
+selftest_clean                  : config_clean
+selftest_clean                  : local_clean config_clean
                                 @$(RM)  $(DIR_LOG)              \
                                         $(DIR_CFG_USER)/*~      \
 …
                                         *.pos                   \
                                         *.stat                  \
+                                        *.log                   \
                                         *.dot                   \
                                         *.txt                   \
                                         generated_by_systemcass \
+                                        semantic.cache          \
                                         core*;
+selftest_clean_all              : library_clean
 selftest_help                   :
 …
                                 $(ECHO) " * all_selftest         : compile all c++ file and execute";\
                                 $(ECHO) " * execute              : execute all instance";\
+                                $(ECHO) " * execute_only         : execute all instance without rebuild all libraries";\
                                 $(ECHO) " * config               : generate configuration with configuration's file" ;\
                                 $(ECHO) " * reconfig             : regenerate configuration with configuration's file" ;\

trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.Synthesis

r81	r88
87	87	$(RM) $(DIR_WORK) transcript Makefile.mkf $(FPGA_CFG_FILE_LOCAL) *.wlf;
88	88
	89	synthesis_clean_all : synthesis_clean
	90
89	91	synthesis_help :
90	92	@\

trunk/IPs/systemC/processor/Morpheo/Behavioural/Makefile.flags

-              r82
+              r88
+#
+#-----[ Simulator ]----------------------------------------
+SIMULATOR                       = systemcass
+#SIMULATOR                      = systemc
+# 3 simulators :
+# systemc                       - SystemC
+# systemcass                    - SystemCASS
+# systemcass_deps               - Systemcass, and use port dependency information instead of sensitivity list
+#-----[ Flags ]--------------------------------------------
+MORPHEO_FLAGS                   =       -DSYSTEMC               \
+                                        -DSTATISTICS            \
+                                        -DDEBUG=DEBUG_TRACE
+#                                       -DVHDL                  \
+#                                       -DVHDL_TESTBENCH        \
+#                                       -DVHDL_TESTBENCH_ASSERT \
+#                                       -DPOSITION              \
+#                                       -DNO_TRANSLATION        \
+# Flags :
+# DEBUG={level}                           - Print Debug Message
+# SYSTEMC                                 - To generate a systemc's model
+# VHDL                                    - To generate a vhdl's    models
+# VHDL_TESTBENCH        (need SYSTEMC)    - In the simulation, generate two testbench's file (input and ouput) to validate the vhdl's model
+# VHDL_TESTBENCH_ASSERT (need SYSTEMC)    - In the simulation, generate in  testbench's file an serie of assert
+# POSITION                                - To generate a position's files     (it's input of viewer)
+# STATISTICS            (need SYSTEMC)    - In the simulation, generate a statistics's file
+# INFORMATION           (need STATISTICS) - Instance Information :
+#                                             * Static    : at the instance creation
+#                                                * register number
+#                                                * worst way
+#                                             * Dynamique : at the runtime
+#                                                * consomation
+# NO_TRANSLATION                          - No translate message
+# NO_INIT                                 - No init a lot of register
+ifeq ($(origin MORPHEO_TOPLEVEL), undefined)
+        $(error "variable MORPHEO_TOPLEVEL is undefined");
+else
+        include $(MORPHEO_TOPLEVEL)/Makefile.flags
+endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/SelfTest/Makefile

r82	r88
24	24	library_clean : @COMPONENT_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/SelfTest/src/main.cpp

-              r83
+              r88
       morpheo::behavioural::@NAMESPACE_USE::Parameters * param = new morpheo::behavioural::@NAMESPACE_USE::Parameters
+        (
+         true //is_toplevel
         );
       msg(_("%s"),param->print(1).c_str());
+      msg(_("%s"),param->print(0).c_str());
       test (name,param);
 …
   catch (morpheo::ErrorMorpheo & error)
+    {
       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
+//       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
       _return = EXIT_FAILURE;
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/SelfTest/src/test.cpp

-              r87
+              r88
+{
   msg(_("<%s> : Simulation SystemC.\n"),name.c_str());
+  if (setlocale (LC_ALL, "") == NULL)
+    msg(_("setlocale ko.\n"));
 #ifdef STATISTICS

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/include/Parameters.h

-              r82
+              r88
     //-----[ methods ]-----------------------------------------------------------
+  public : Parameters  ();
+//   public : Parameters  (Parameters & param) ;
+  public : ~Parameters () ;
+  public : Parameters  (bool is_toplevel=false);
+//public : Parameters  (Parameters & param) ;
+  public : ~Parameters (void);
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
 …
   public :        std::string     print      (uint32_t depth);
   public : friend std::ostream&   operator<< (std::ostream& output_stream,
                                             morpheo::behavioural::@NAMESPACE_USE::Parameters & x);
+                                              morpheo::behavioural::@NAMESPACE_USE::Parameters & x);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/src/New_Component.cpp

-              r82
+              r88
     usage_environment(_usage);
     log_printf(INFO,@COMPONENT,FUNCTION,_("Allocation"));
+    log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Allocation"),_name.c_str());
     allocation (
 …
     if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,@COMPONENT,FUNCTION,_("Allocation of statistics"));
+        log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Allocation of statistics"),_name.c_str());
         statistics_allocation(param_statistics);
 …
+      {
         // generate the vhdl
         log_printf(INFO,@COMPONENT,FUNCTION,_("Generate the vhdl"));
+        log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Generate the vhdl"),_name.c_str());
         vhdl();
 …
     if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,@COMPONENT,FUNCTION,_("Method - transition"));
+        log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Method - transition"),_name.c_str());
         SC_METHOD (transition);
 …
         // List dependency information
 # endif
+//      log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Method - genMoore"),_name.c_str());
+//      SC_METHOD (genMoore);
+//      dont_initialize ();
+//      sensitive << (*(in_CLOCK)).neg(); // need internal register
+// # ifdef SYSTEMCASS_SPECIFIC
+//      // List dependency information
+// # endif
 #endif
 …
 #endif
     log_printf(INFO,@COMPONENT,FUNCTION,_("Deallocation"));
+    log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Deallocation"),_name.c_str());
     deallocation ();

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/src/New_Component_statistics_deallocation.cpp

r82	r88
19	19	log_begin(@COMPONENT,FUNCTION);
20	20
21		log_printf(INFO,@COMPONENT,FUNCTION,_("~~Generate Statistics file"~~));
	21	log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Generate Statistics file"),_name.c_str());
22	22
23	23	delete _stat;

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vbe/src/Parameters.cpp

-              r82
+              r88
 #undef  FUNCTION
 #define FUNCTION "@COMPONENT::Parameters"
   Parameters::Parameters ()
+  Parameters::Parameters (bool is_toplevel)
+  {
     log_begin(@COMPONENT,FUNCTION);
     test();
+    if (is_toplevel)
+      {
+        copy();
+      }
     log_end(@COMPONENT,FUNCTION);
   };
 …
 #undef  FUNCTION
 #define FUNCTION "@COMPONENT::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_begin(@COMPONENT,FUNCTION);
+    log_end(@COMPONENT,FUNCTION);
+  };
+#undef  FUNCTION
+#define FUNCTION "@COMPONENT::copy"
+  void Parameters::copy (void)
+  {
     log_begin(@COMPONENT,FUNCTION);

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/SelfTest/Makefile

r82	r88
24	24	library_clean : @COMPONENT_library_clean
25	25
	26	local_clean :
	27
26	28	include $(DIR_COMPONENT)/Makefile.deps
27	29	include $(DIR_MORPHEO)/Behavioural/Makefile.flags

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/SelfTest/src/main.cpp

-              r83
+              r88
       morpheo::behavioural::@NAMESPACE_USE::Parameters * param = new morpheo::behavioural::@NAMESPACE_USE::Parameters
+        (
+         true // is_toplevel
         );
       msg(_("%s"),param->print(1).c_str());
+      msg(_("%s"),param->print(0).c_str());
       test (name,param);
 …
   catch (morpheo::ErrorMorpheo & error)
+    {
       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
+//       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
       _return = EXIT_FAILURE;
+    }

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/SelfTest/src/test.cpp

-              r87
+              r88
+{
   msg(_("<%s> : Simulation SystemC.\n"),name.c_str());
+  if (setlocale (LC_ALL, "") == NULL)
+    msg(_("setlocale ko.\n"));
 #ifdef STATISTICS

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/include/Parameters.h

-              r82
+              r88
     //-----[ methods ]-----------------------------------------------------------
+  public : Parameters  ();
+//   public : Parameters  (Parameters & param) ;
+  public : ~Parameters () ;
+  public : Parameters  (bool is_toplevel=false);
+//public : Parameters  (Parameters & param) ;
+  public : ~Parameters (void);
+  public :        void            copy       (void);
   public :        Parameters_test msg_error  (void);
   public :        std::string     print      (uint32_t depth);
   public : friend std::ostream&   operator<< (std::ostream& output_stream,
                                             morpheo::behavioural::@NAMESPACE_USE::Parameters & x);
+  public : friend std::ostream&   operator<< (std::ostream& output,
+                                              morpheo::behavioural::@NAMESPACE_USE::Parameters & x);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/src/New_Component.cpp

-              r82
+              r88
     usage_environment(_usage);
     log_printf(INFO,@COMPONENT,FUNCTION,_("Allocation"));
+    log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Allocation"),_name.c_str());
     allocation (
 …
     if (usage_is_set(_usage,USE_STATISTICS))
+      {
         log_printf(INFO,@COMPONENT,FUNCTION,_("Allocation of statistics"));
+        log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Allocation of statistics"),_name.c_str());
         statistics_allocation(param_statistics);
 …
+      {
         // generate the vhdl
         log_printf(INFO,@COMPONENT,FUNCTION,_("Generate the vhdl"));
+        log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Generate the vhdl"),_name.c_str());
         vhdl();
 …
     if (usage_is_set(_usage,USE_SYSTEMC))
+      {
         log_printf(INFO,@COMPONENT,FUNCTION,_("Method - transition"));
+        log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Method - transition"),_name.c_str());
         SC_METHOD (transition);
 …
 #endif
     log_printf(INFO,@COMPONENT,FUNCTION,_("Deallocation"));
+    log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Deallocation"),_name.c_str());
     deallocation ();

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/src/New_Component_statistics_deallocation.cpp

r82	r88
19	19	log_begin(@COMPONENT,FUNCTION);
20	20
21		log_printf(INFO,@COMPONENT,FUNCTION,_("~~Generate Statistics file"~~));
	21	log_printf(INFO,@COMPONENT,FUNCTION,_("<%s> : Generate Statistics file"),_name.c_str());
22	22
23	23	delete _stat;

trunk/IPs/systemC/processor/Morpheo/Behavioural/New_Component_vst/src/Parameters.cpp

-              r82
+              r88
 #undef  FUNCTION
 #define FUNCTION "@COMPONENT::Parameters"
   Parameters::Parameters ()
+  Parameters::Parameters (bool is_toplevel)
+  {
     log_begin(@COMPONENT,FUNCTION);
     test();
+    if (is_toplevel)
+      {
+        copy();
+      }
     log_end(@COMPONENT,FUNCTION);
   };
 …
 #undef  FUNCTION
 #define FUNCTION "@COMPONENT::~Parameters"
+  Parameters::~Parameters ()
+  Parameters::~Parameters (void)
+  {
+    log_begin(@COMPONENT,FUNCTION);
+    log_end(@COMPONENT,FUNCTION);
+  };
+#undef  FUNCTION
+#define FUNCTION "@COMPONENT::copy"
+  void Parameters::copy (void)
+  {
     log_begin(@COMPONENT,FUNCTION);

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Allocation.h

-              r82
+              r88
 #include "Common/include/Debug.h"
+// ======================================================================
+// =====[ ALLOCATION / DELETE of ARRAY ]=================================
+// ======================================================================
+#define ALLOC1(var,type,s1)                      \
+  var = new type [s1]
+#define ALLOC2(var,type,s1,s2)                   \
+  var = new type * [s1];                         \
+  for (uint32_t it1=0; it1<s1; ++it1)            \
+    {                                            \
+      var [it1] = new type [s2];                 \
+    }
+#define ALLOC3(var,type,s1,s2,s3)                \
+  var = new type ** [s1];                        \
+  for (uint32_t it1=0; it1<s1; ++it1)            \
+    {                                            \
+      var [it1] = new type * [s2];               \
+      for (uint32_t it2=0; it2<s2; ++it2)        \
+        {                                        \
+          var [it1][it2] = new type [s3];        \
+        }                                        \
+    }
+#define ALLOC4(var,type,s1,s2,s3,s4)                    \
+  var = new type *** [s1];                              \
+  for (uint32_t it1=0; it1<s1; ++it1)                   \
+    {                                                   \
+      var [it1] = new type ** [s2];                     \
+      for (uint32_t it2=0; it2<s2; ++it2)               \
+        {                                               \
+          var [it1][it2] = new type * [s3];             \
+          for (uint32_t it3=0; it3<s3; ++it3)           \
+            {                                           \
+              var [it1][it2][it3] = new type [s4];      \
+            }                                           \
+        }                                               \
+    }
+#define DELETE1(var,s1)                          \
+  delete [] var;
+#define DELETE2(var,s1,s2)                       \
+  for (uint32_t it1=0; it1<s1; ++it1)            \
+    {                                            \
+      delete [] var [it1];                       \
+    }                                            \
+  delete [] var;
+#define DELETE3(var,s1,s2,s3)                    \
+  for (uint32_t it1=0; it1<s1; ++it1)            \
+    {                                            \
+      for (uint32_t it2=0; it2<s2; ++it2)        \
+        {                                        \
+          delete [] var [it1][it2];              \
+        }                                        \
+      delete [] var [it1];                       \
+    }                                            \
+  delete [] var;
+#define DELETE4(var,s1,s2,s3,s4)                 \
+  for (uint32_t it1=0; it1<s1; ++it1)            \
+    {                                            \
+      for (uint32_t it2=0; it2<s2; ++it2)        \
+        {                                        \
+          for (uint32_t it3=0; it3<s3; ++it3)    \
+            {                                    \
+              delete [] var [it1][it2][it3];     \
+            }                                    \
+          delete [] var [it1][it2];              \
+        }                                        \
+      delete [] var [it1];                       \
+    }                                            \
+  delete [] var;
+// ======================================================================
+// =====[ ALLOCATION / DELETE of SIGNAL]=================================
+// ======================================================================
 // Help to allocate interface
+#define INTERFACE_PRINT(name) log_printf(TRACE,true,"allocation","Interface's creation : %s (%s, %d)",name,__FILE__,__LINE__);
+#define INTERFACE_PRINT(name) log_printf(TRACE,Allocation,FUNCTION,"<%s> : Interface's creation : %s (%s, %d)",_name.c_str(),name,__FILE__,__LINE__);
+#define PRINT_SIGNAL_ADDRESS(name,address) log_printf(TRACE,Allocation,FUNCTION,"Signal : %s 0x%.8x(%s, %d)",name,(uint32_t)((uint64_t)(address)),__FILE__,__LINE__);
+#define PRINT_SIZE_NUL(component,interface,signal) log_printf(TRACE,Allocation,FUNCTION,_("<%s> %s.%s.%s : size is nul."),_name.c_str(),component->get_name().c_str(),interface->get_name().c_str(),signal);
+#define TEST_SIGNAL(name,address) PRINT_SIGNAL_ADDRESS(name,address); TEST_PTR(address)
 // ----------------------------------------------------------------------
 …
 // ----------------------------------------------------------------------
 #define __ALLOC_SIGNAL(sig, name, type)         \
   {                                             \
     sig = new type (name);                      \
+#define __ALLOC_SIGNAL(sig, name, type)         \
+  {                                             \
+    sig = new type (name);                      \
+  }
 #ifdef POSITION
 #define ALLOC_INTERFACE( name, direction, localisation, str)            \
   INTERFACE_PRINT(name);                                                \
   Interface_fifo * interface = _interfaces->set_interface( name, direction, localisation, str);
+#define ALLOC_INTERFACE( name, direction, localisation, str)            \
+  INTERFACE_PRINT(name);                                                \
+  morpheo::behavioural::Interface_fifo * interface = _interfaces->set_interface( name, direction, localisation, str);
 #else
 #define ALLOC_INTERFACE( name, direction, localisation, str)            \
   INTERFACE_PRINT(name);                                                \
   Interface_fifo * interface = _interfaces->set_interface( name);
+#define ALLOC_INTERFACE( name, direction, localisation, str)            \
+  INTERFACE_PRINT(name);                                                \
+  morpheo::behavioural::Interface_fifo * interface = _interfaces->set_interface( name);
 #endif
 #define ALLOC_VAL_ACK_IN(  sig, name, type)                             \
   {                                                                     \
     sig = interface->set_signal_valack_in (name, type);                 \
+  }
 #define ALLOC_VAL_ACK_OUT( sig, name, type)                             \
   {                                                                     \
     sig = interface->set_signal_valack_out(name, type);                 \
+  }
 #define ALLOC_VALACK_IN(     sig, type)                                 \
   {                                                                     \
     sig = interface->set_signal_valack_in (type);                       \
+  }
 #define ALLOC_VALACK_OUT(    sig, type)                                 \
   {                                                                     \
     sig = interface->set_signal_valack_out(type);                       \
+  }
 #define ALLOC_SIGNAL_IN(  sig, name, type, size)                        \
   if (size > 0)                                                         \
     {                                                                   \
       sig = interface->set_signal_in <type> (name, size);               \
     }                                                                   \
   else                                                                  \
     {                                                                   \
       log_printf(INFO,true,FUNCTION,_("%s %s.%s.%s : size is nul."),MSG_INFORMATION,_component->get_name().c_str(),interface->get_name().c_str(),name); \
+#define ALLOC_VAL_ACK_IN(  sig, name, type)                             \
+  {                                                                     \
+    sig = interface->set_signal_valack_in (name, type);                 \
+  }
+#define ALLOC_VAL_ACK_OUT( sig, name, type)                             \
+  {                                                                     \
+    sig = interface->set_signal_valack_out(name, type);                 \
+  }
+#define ALLOC_VALACK_IN(     sig, type)                                 \
+  {                                                                     \
+    sig = interface->set_signal_valack_in (type);                       \
+  }
+#define ALLOC_VALACK_OUT(    sig, type)                                 \
+  {                                                                     \
+    sig = interface->set_signal_valack_out(type);                       \
+  }
+#define ALLOC_SIGNAL_IN(  sig, name, type, size)                        \
+  if (size > 0)                                                         \
+    {                                                                   \
+      sig = interface->set_signal_in <type> (name, size);               \
+    }                                                                   \
+  else                                                                  \
+    {                                                                   \
+      PRINT_SIZE_NUL(_component,interface,name);                        \
+    }
 #define ALLOC_SIGNAL_OUT( sig, name, type, size)                        \
   if (size > 0)                                                         \
     {                                                                   \
       sig = interface->set_signal_out<type> (name, size);               \
     }                                                                   \
   else                                                                  \
     {                                                                   \
       log_printf(INFO,true,FUNCTION,_("%s %s.%s.%s : size is nul."),MSG_INFORMATION,_component->get_name().c_str(),interface->get_name().c_str(),name); \
+#define ALLOC_SIGNAL_OUT( sig, name, type, size)                        \
+  if (size > 0)                                                         \
+    {                                                                   \
+      sig = interface->set_signal_out<type> (name, size);               \
+    }                                                                   \
+  else                                                                  \
+    {                                                                   \
+      PRINT_SIZE_NUL(_component,interface,name); \
+    }
 #define DELETE_SIGNAL( sig, size)                                       \
   if (size > 0)                                                         \
     {                                                                   \
       delete sig;                                                       \
+#define DELETE_SIGNAL( sig, size)                                       \
+  if (size > 0)                                                         \
+    {                                                                   \
+      delete sig;                                                       \
+    }
+#define ALLOC_SC_SIGNAL(  sig, name, type)                              \
+  sc_signal<type> * sig = new sc_signal<type> (name);
+#define INSTANCE_SC_SIGNAL(component, sig)      \
+  {                                             \
+    TEST_PTR(component->sig);                   \
+    TEST_PTR(sig);                              \
+    (*(component->sig)) (*(sig));               \
+  }
+#define DELETE_SC_SIGNAL( sig)                  \
+  {                                             \
+    delete sig;                                 \
+  }
+#define ALLOC_SC_SIGNAL(  sig, name, type)                              \
+  sc_signal<type> * sig = new sc_signal<type> (name);                   \
+  PRINT_SIGNAL_ADDRESS(name,sig);
+#define INSTANCE_SC_SIGNAL(component, sig)                     \
+  {                                                            \
+    TEST_SIGNAL(component->sig->name(),component->sig);        \
+    TEST_SIGNAL(sig           ->name(),sig);                   \
+    (*(component->sig)) (*(sig));                              \
+  }
+#define _INSTANCE_SC_SIGNAL(component, sig1,sig2)                       \
+  {                                                                     \
+    TEST_SIGNAL(component->sig1->name(),component->sig1);               \
+    TEST_SIGNAL(sig2           ->name(),sig2);                          \
+    (*(component->sig1)) (*(sig2));                                     \
+  }
+#define DELETE_SC_SIGNAL( sig)                  \
+  {                                             \
+    delete sig;                                 \
+  }
+#define __ALLOC0_SIGNAL(sig, name, type)                      __ALLOC_SIGNAL(sig, name, type)
+#define ALLOC0_INTERFACE( name, direction, localisation, str) ALLOC_INTERFACE( name, direction, localisation, str)
+#define ALLOC0_VAL_ACK_IN(  sig, name, type)                  ALLOC_VAL_ACK_IN(  sig, name, type)
+#define ALLOC0_VAL_ACK_OUT( sig, name, type)                  ALLOC_VAL_ACK_OUT( sig, name, type)
+#define ALLOC0_VALACK_IN(     sig, type)                      ALLOC_VALACK_IN(     sig, type)
+#define ALLOC0_VALACK_OUT(    sig, type)                      ALLOC_VALACK_OUT(    sig, type)
+#define ALLOC0_SIGNAL_IN(  sig, name, type, size)             ALLOC_SIGNAL_IN(  sig, name, type, size)
+#define ALLOC0_SIGNAL_OUT( sig, name, type, size)             ALLOC_SIGNAL_OUT( sig, name, type, size)
+#define DELETE0_SIGNAL( sig, size)                            DELETE_SIGNAL( sig, size)
+#define ALLOC0_SC_SIGNAL(  sig, name, type)                   ALLOC_SC_SIGNAL(  sig, name, type)
+#define INSTANCE0_SC_SIGNAL(component, sig)                   INSTANCE_SC_SIGNAL(component, sig)
+#define _INSTANCE0_SC_SIGNAL(component, sig)                  _INSTANCE_SC_SIGNAL(component, sig)
+#define DELETE0_SC_SIGNAL( sig)                               DELETE_SC_SIGNAL( sig)
 // ----------------------------------------------------------------------
 …
 // ----------------------------------------------------------------------
 #define __ALLOC1_INTERFACE(name, it1)                                   \
   INTERFACE_PRINT(name);                                                \
   const std::string interface_name = name;                              \
   const uint32_t iterator_1 = it1;
 #define __ALLOC1_SIGNAL_IN( sig, name, type)            \
   {                                                                     \
     sig = new SC_IN(type) * [iterator_1];                               \
     std::string separator="_";                                          \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
       {                                                                 \
         std::string str = "in_"+interface_name+separator+toString(alloc_signal_it1)+separator+name; \
         sig [alloc_signal_it1] = new SC_IN(type) (str.c_str());         \
       }                                                                 \
+  }
 #define __ALLOC1_SIGNAL_OUT( sig, name, type)           \
   {                                                                     \
     sig = new SC_OUT(type) * [iterator_1];                              \
     std::string separator="_";                                          \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
       {                                                                 \
         std::string str = "out_"+interface_name+separator+toString(alloc_signal_it1)+separator+name; \
         sig [alloc_signal_it1] = new SC_OUT(type) (str.c_str());                \
       }                                                                 \
+#define __ALLOC1_INTERFACE(name, x1)                                    \
+  INTERFACE_PRINT(name);                                                \
+  const std::string interface_name = name;                              \
+  const uint32_t iterator_1 = x1;
+#define __ALLOC1_SIGNAL_IN( sig, name, type)                            \
+  {                                                                     \
+    sig = new SC_IN(type) * [iterator_1];                               \
+    std::string separator="_";                                          \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        std::string str = "in_"+interface_name+separator+toString(it1)+separator+name; \
+        sig [it1] = new SC_IN(type) (str.c_str());                      \
+      }                                                                 \
+  }
+#define __ALLOC1_SIGNAL_OUT( sig, name, type)                           \
+  {                                                                     \
+    sig = new SC_OUT(type) * [iterator_1];                              \
+    std::string separator="_";                                          \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        std::string str = "out_"+interface_name+separator+toString(it1)+separator+name; \
+        sig [it1] = new SC_OUT(type) (str.c_str());                     \
+      }                                                                 \
+  }
 #ifdef POSITION
 #define ALLOC1_INTERFACE( name, direction, localisation, str, it1)      \
   INTERFACE_PRINT(name);                                                \
   const uint32_t iterator_1 = it1;                                      \
   Interface_fifo * interface [iterator_1];                              \
   {                                                                     \
     std::string separator="_";                                          \
     for (uint32_t alloc_interface_it1=0; alloc_interface_it1<iterator_1; alloc_interface_it1++) \
       {                                                                 \
         interface [alloc_interface_it1] = _interfaces->set_interface( name+separator+toString(alloc_interface_it1), direction, localisation, str); \
       }                                                                 \
+#define ALLOC1_INTERFACE( name, direction, localisation, str, x1)       \
+  INTERFACE_PRINT(name);                                                \
+  const uint32_t iterator_1 = x1;                                       \
+  morpheo::behavioural::Interface_fifo * interface [iterator_1];        \
+  {                                                                     \
+    std::string separator="_";                                          \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        interface [it1] = _interfaces->set_interface( name+separator+toString(it1), direction, localisation, str); \
+      }                                                                 \
+  }
 #else
 #define ALLOC1_INTERFACE( name, direction, localisation, str, it1)      \
   INTERFACE_PRINT(name);                                                \
   const uint32_t iterator_1 = it1;                                      \
   Interface_fifo * interface [iterator_1];                              \
   {                                                                     \
     std::string separator="_";                                          \
     for (uint32_t alloc_interface_it1=0; alloc_interface_it1<iterator_1; alloc_interface_it1++) \
       {                                                                 \
         interface [alloc_interface_it1] = _interfaces->set_interface( name+separator+toString(alloc_interface_it1)); \
       }                                                                 \
+#define ALLOC1_INTERFACE( name, direction, localisation, str, x1)       \
+  INTERFACE_PRINT(name);                                                \
+  const uint32_t iterator_1 = x1;                                       \
+  morpheo::behavioural::Interface_fifo * interface [iterator_1];        \
+  {                                                                     \
+    std::string separator="_";                                          \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        interface [it1] = _interfaces->set_interface( name+separator+toString(it1)); \
+      }                                                                 \
+  }
 #endif
+#define ALLOC1_VAL_ACK_IN( sig, name, type)                             \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
+      {                                                                 \
+        sig [alloc_signal_it1] = interface[alloc_signal_it1]->set_signal_valack_in (name, type); \
+      }                                                                 \
+  }
+#define ALLOC1_VAL_ACK_OUT(sig, name, type)                             \
+  {                                                                     \
+    sig = new SC_OUT(Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
+      {                                                                 \
+        sig [alloc_signal_it1] = interface[alloc_signal_it1]->set_signal_valack_out(name, type); \
+      }                                                                 \
+  }
+#define ALLOC1_VALACK_IN(    sig, type)                                 \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
+      {                                                                 \
+        sig [alloc_signal_it1] = interface[alloc_signal_it1]->set_signal_valack_in (type); \
+      }                                                                 \
+  }
+#define ALLOC1_VALACK_OUT(   sig, type)                                 \
+  {                                                                     \
+    sig = new SC_OUT(Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
+      {                                                                 \
+        sig [alloc_signal_it1] = interface[alloc_signal_it1]->set_signal_valack_out(type); \
+      }                                                                 \
+  }
+#define ALLOC1_SIGNAL_IN( sig, name, type, size)                        \
+  {                                                                     \
+    sig = new SC_IN (type) * [iterator_1];                              \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
+      {                                                                 \
+        if (size > 0)                                                   \
+          {                                                             \
+            sig [alloc_signal_it1] = interface[alloc_signal_it1]->set_signal_in <type> (name, size); \
+          }                                                             \
+        else                                                            \
+          {                                                             \
+            log_printf(INFO,true,FUNCTION,_("%s %s.%s.%s : size is nul."),MSG_INFORMATION,_component->get_name().c_str(),interface[alloc_signal_it1]->get_name().c_str(),name); \
+          }                                                             \
+      }                                                                 \
+  }
+#define ALLOC1_SIGNAL_OUT(sig, name, type, size)                        \
+  {                                                                     \
+    sig = new SC_OUT(type) * [iterator_1];                              \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<iterator_1; alloc_signal_it1++) \
+      {                                                                 \
+        if (size > 0)                                                   \
+          {                                                             \
+            sig [alloc_signal_it1] = interface[alloc_signal_it1]->set_signal_out<type> (name, size); \
+          }                                                             \
+        else                                                            \
+          {                                                             \
+            log_printf(INFO,true,FUNCTION,_("%s %s.%s.%s : size is nul."),MSG_INFORMATION,_component->get_name().c_str(),interface[alloc_signal_it1]->get_name().c_str(),name); \
+          }                                                             \
+      }                                                                 \
+  }
+#define DELETE1_SIGNAL(sig, it1, size)                                  \
+  {                                                                     \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+      {                                                                 \
+        if (size > 0)                                                   \
+          {                                                             \
+            delete sig[alloc_signal_it1];                               \
+          }                                                             \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#define ALLOC1_SC_SIGNAL( sig, name, type, it1)                         \
+  sc_signal<type> ** sig = new sc_signal<type> * [it1];                 \
+  {                                                                     \
+    std::string separator="_";                                          \
+    std::string str;                                                    \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+      {                                                                 \
+        str = name+separator+toString(alloc_signal_it1);                \
+        sig [alloc_signal_it1] = new sc_signal<type> (str.c_str());     \
+      }                                                                 \
+  }
+#define INSTANCE1_SC_SIGNAL(component, sig, it1)                        \
+  for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+    {                                                                   \
+      TEST_PTR(component->sig [alloc_signal_it1]);                      \
+      TEST_PTR(sig            [alloc_signal_it1]);                      \
+      (*(component->sig[alloc_signal_it1])) (*(sig[alloc_signal_it1])); \
+#define ALLOC1_VAL_ACK_IN( sig, name, type)                             \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        sig [it1] = interface[it1]->set_signal_valack_in (name, type);  \
+      }                                                                 \
+  }
+#define ALLOC1_VAL_ACK_OUT(sig, name, type)                             \
+  {                                                                     \
+    sig = new SC_OUT(Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        sig [it1] = interface[it1]->set_signal_valack_out(name, type);  \
+      }                                                                 \
+  }
+#define ALLOC1_VALACK_IN(    sig, type)                                 \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        sig [it1] = interface[it1]->set_signal_valack_in (type);        \
+      }                                                                 \
+  }
+#define ALLOC1_VALACK_OUT(   sig, type)                                 \
+  {                                                                     \
+    sig = new SC_OUT(Tcontrol_t) * [iterator_1];                        \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        sig [it1] = interface[it1]->set_signal_valack_out(type);        \
+      }                                                                 \
+  }
+#define ALLOC1_SIGNAL_IN( sig, name, type, size)                        \
+  {                                                                     \
+    sig = new SC_IN (type) * [iterator_1];                              \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        if (size > 0)                                                   \
+          {                                                             \
+            sig [it1] = interface[it1]->set_signal_in <type> (name, size); \
+          }                                                             \
+        else                                                            \
+          {                                                             \
+            PRINT_SIZE_NUL(_component,interface[it1],name);             \
+          }                                                             \
+      }                                                                 \
+  }
+#define ALLOC1_SIGNAL_OUT(sig, name, type, size)                        \
+  {                                                                     \
+    sig = new SC_OUT(type) * [iterator_1];                              \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        if (size > 0)                                                   \
+          {                                                             \
+            sig [it1] = interface[it1]->set_signal_out<type> (name, size); \
+          }                                                             \
+        else                                                            \
+          {                                                             \
+            PRINT_SIZE_NUL(_component,interface[it1],name);             \
+          }                                                             \
+      }                                                                 \
+  }
+#define DELETE1_SIGNAL(sig, x1, size)                                   \
+  {                                                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        if (size > 0)                                                   \
+          {                                                             \
+            delete sig[it1];                                            \
+          }                                                             \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#define ALLOC1_SC_SIGNAL( sig, name, type, x1)                          \
+  sc_signal<type> ** sig = new sc_signal<type> * [x1];                  \
+  {                                                                     \
+    std::string separator="_";                                          \
+    std::string str;                                                    \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        str = name+separator+toString(it1);                             \
+        sig [it1] = new sc_signal<type> (str.c_str());                  \
+        PRINT_SIGNAL_ADDRESS(str.c_str(),sig[it1]);                     \
+      }                                                                 \
+  }
+#define INSTANCE1_SC_SIGNAL(component, sig, x1) \
+  for (uint32_t it1=0; it1<x1; it1++)                                   \
+    {                                                                   \
+      TEST_SIGNAL(component->sig [it1]->name(),component->sig [it1]);   \
+      TEST_SIGNAL(sig            [it1]->name(),sig            [it1]);   \
+      (*(component->sig[it1])) (*(sig[it1]));                           \
+    }
+#define DELETE1_SC_SIGNAL(sig, it1)                                     \
+  {                                                                     \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+      {                                                                 \
+        delete sig[alloc_signal_it1];                                   \
+      }                                                                 \
+    delete [] sig;                                                      \
+#define _INSTANCE1_SC_SIGNAL(component, sig1, sig2, x1) \
+  for (uint32_t it1=0; it1<x1; it1++)                                   \
+    {                                                                   \
+      TEST_SIGNAL(component->sig1 [it1]->name(),component->sig1 [it1]); \
+      TEST_SIGNAL(sig2            [it1]->name(),sig2            [it1]); \
+      (*(component->sig1[it1])) (*(sig2[it1]));                         \
+    }
+#define DELETE1_SC_SIGNAL(sig, x1)                                      \
+  {                                                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        delete sig[it1];                                                \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
 …
 #ifdef POSITION
 #define ALLOC2_INTERFACE( name, direction, localisation, str, it1, it2) \
   INTERFACE_PRINT(name);                                                \
   uint32_t iterator_1 = 0;                                              \
   uint32_t iterator_2 = 0;                                              \
   Interface_fifo *** interface;                                         \
   {                                                                     \
     std::string separator="_";                                          \
     iterator_1 = it1;                                                   \
     interface = new Interface_fifo ** [iterator_1];                     \
     for (uint32_t alloc_interface_it1=0; alloc_interface_it1<iterator_1; alloc_interface_it1++) \
       {                                                                 \
         iterator_2 = it2;                                               \
         interface [alloc_interface_it1] = new Interface_fifo * [iterator_2]; \
         for (uint32_t alloc_interface_it2=0; alloc_interface_it2<iterator_2; alloc_interface_it2++) \
           {                                                             \
             interface [alloc_interface_it1][alloc_interface_it2] = _interfaces->set_interface( name+separator+toString(alloc_interface_it1)+separator+toString(alloc_interface_it2), direction, localisation, str); \
           }                                                             \
       }                                                                 \
+#define ALLOC2_INTERFACE( name, direction, localisation, str, x1, x2)   \
+  INTERFACE_PRINT(name);                                                \
+  uint32_t iterator_1 = 0;                                              \
+  uint32_t iterator_2 = 0;                                              \
+  morpheo::behavioural::Interface_fifo *** interface;                   \
+  {                                                                     \
+    std::string separator="_";                                          \
+    iterator_1 = x1;                                                    \
+    interface = new morpheo::behavioural::Interface_fifo ** [iterator_1]; \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        iterator_2 = x2;                                                \
+        interface [it1] = new morpheo::behavioural::Interface_fifo * [iterator_2]; \
+        for (uint32_t it2=0; it2<iterator_2; it2++)                     \
+          {                                                             \
+            interface [it1][it2] = _interfaces->set_interface( name+separator+toString(it1)+separator+toString(it2), direction, localisation, str); \
+          }                                                             \
+      }                                                                 \
+  }
 #else
 #define ALLOC2_INTERFACE( name, direction, localisation, str, it1, it2) \
   INTERFACE_PRINT(name);                                                \
   uint32_t iterator_1 = 0;                                              \
   uint32_t iterator_2 = 0;                                              \
   Interface_fifo *** interface;                                         \
   {                                                                     \
     std::string separator="_";                                          \
     iterator_1 = it1;                                                   \
     interface = new Interface_fifo ** [iterator_1];                     \
     for (uint32_t alloc_interface_it1=0; alloc_interface_it1<iterator_1; alloc_interface_it1++) \
       {                                                                 \
         iterator_2 = it2;                                               \
         interface [alloc_interface_it1] = new Interface_fifo * [iterator_2]; \
         for (uint32_t alloc_interface_it2=0; alloc_interface_it2<iterator_2; alloc_interface_it2++) \
           {                                                             \
             interface [alloc_interface_it1][alloc_interface_it2] = _interfaces->set_interface( name+separator+toString(alloc_interface_it1)+separator+toString(alloc_interface_it2)); \
           }                                                             \
       }                                                                 \
+#define ALLOC2_INTERFACE( name, direction, localisation, str, x1, x2)   \
+  INTERFACE_PRINT(name);                                                \
+  uint32_t iterator_1 = 0;                                              \
+  uint32_t iterator_2 = 0;                                              \
+  morpheo::behavioural::Interface_fifo *** interface;                   \
+  {                                                                     \
+    std::string separator="_";                                          \
+    iterator_1 = x1;                                                    \
+    interface = new morpheo::behavioural::Interface_fifo ** [iterator_1]; \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        iterator_2 = x2;                                                \
+        interface [it1] = new morpheo::behavioural::Interface_fifo * [iterator_2]; \
+        for (uint32_t it2=0; it2<iterator_2; it2++)                     \
+          {                                                             \
+            interface [it1][it2] = _interfaces->set_interface( name+separator+toString(it1)+separator+toString(it2)); \
+          }                                                             \
+      }                                                                 \
+  }
 #endif
 #define _ALLOC2_VAL_ACK_IN( sig, name, type, it1, it2)                  \
   {                                                                     \
     sig = new SC_IN (Tcontrol_t) ** [it1];                              \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
       {                                                                 \
         sig [alloc_signal_it1] = new SC_IN (Tcontrol_t) * [it2];        \
         for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
           {                                                             \
             sig [alloc_signal_it1][alloc_signal_it2] = interface[alloc_signal_it1][alloc_signal_it2]->set_signal_valack_in (name, type); \
           }                                                             \
       }                                                                 \
+  }
 #define _ALLOC2_VAL_ACK_OUT( sig, name, type, it1, it2)                 \
   {                                                                     \
     sig = new SC_OUT (Tcontrol_t) ** [it1];                             \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
       {                                                                 \
         sig [alloc_signal_it1] = new SC_OUT (Tcontrol_t) * [it2];       \
         for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
           {                                                             \
             sig [alloc_signal_it1][alloc_signal_it2] = interface[alloc_signal_it1][alloc_signal_it2]->set_signal_valack_out (name, type); \
           }                                                             \
       }                                                                 \
+  }
 #define _ALLOC2_VALACK_IN(    sig,type, it1, it2)                       \
   {                                                                     \
     sig = new SC_IN (Tcontrol_t) ** [it1];                              \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
       {                                                                 \
         sig [alloc_signal_it1] = new SC_IN (Tcontrol_t) * [it2];        \
         for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
           {                                                             \
             sig [alloc_signal_it1][alloc_signal_it2] = interface[alloc_signal_it1][alloc_signal_it2]->set_signal_valack_in (type); \
           }                                                             \
       }                                                                 \
+  }
 #define _ALLOC2_VALACK_OUT(    sig,type, it1, it2)                      \
   {                                                                     \
     sig = new SC_OUT (Tcontrol_t) ** [it1];                             \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
       {                                                                 \
         sig [alloc_signal_it1] = new SC_OUT (Tcontrol_t) * [it2];       \
         for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
           {                                                             \
             sig [alloc_signal_it1][alloc_signal_it2] = interface[alloc_signal_it1][alloc_signal_it2]->set_signal_valack_out (type); \
           }                                                             \
       }                                                                 \
+  }
 #define _ALLOC2_SIGNAL_IN( sig, name, type, size, it1, it2)             \
   {                                                                     \
     sig = new SC_IN (type) ** [it1];                                    \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
       {                                                                 \
         sig [alloc_signal_it1] = new SC_IN (type) * [it2];              \
         for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
           {                                                             \
             if (size > 0)                                               \
               {                                                         \
                 sig [alloc_signal_it1][alloc_signal_it2] = interface[alloc_signal_it1][alloc_signal_it2]->set_signal_in <type> (name, size); \
               }                                                         \
             else                                                        \
               {                                                         \
                 log_printf(INFO,true,FUNCTION,_("%s %s.%s.%s : size is nul."),MSG_INFORMATION,_component->get_name().c_str(),interface[alloc_signal_it1][alloc_signal_it2]->get_name().c_str(),name); \
               }                                                         \
           }                                                             \
       }                                                                 \
+  }
 #define _ALLOC2_SIGNAL_OUT( sig, name, type, size, it1, it2)            \
   {                                                                     \
     sig = new SC_OUT (type) ** [it1];                                   \
     for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
       {                                                                 \
         sig [alloc_signal_it1] = new SC_OUT (type) * [it2];             \
         for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
           {                                                             \
             if (size > 0)                                               \
               {                                                         \
                 sig [alloc_signal_it1][alloc_signal_it2] = interface[alloc_signal_it1][alloc_signal_it2]->set_signal_out <type> (name, size); \
               }                                                         \
             else                                                        \
               {                                                         \
                 log_printf(INFO,true,FUNCTION,_("%s %s.%s.%s : size is nul."),MSG_INFORMATION,_component->get_name().c_str(),interface[alloc_signal_it1][alloc_signal_it2]->get_name().c_str(),name); \
               }                                                         \
           }                                                             \
       }                                                                 \
+#define _ALLOC2_VAL_ACK_IN( sig, name, type, x1, x2)                    \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) ** [x1];                               \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_IN (Tcontrol_t) * [x2];                      \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = interface[it1][it2]->set_signal_valack_in (name, type); \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC2_VAL_ACK_OUT( sig, name, type, x1, x2)                   \
+  {                                                                     \
+    sig = new SC_OUT (Tcontrol_t) ** [x1];                              \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_OUT (Tcontrol_t) * [x2];                     \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = interface[it1][it2]->set_signal_valack_out (name, type); \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC2_VALACK_IN(    sig,type, x1, x2)                         \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) ** [x1];                               \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_IN (Tcontrol_t) * [x2];                      \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = interface[it1][it2]->set_signal_valack_in (type); \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC2_VALACK_OUT(    sig,type, x1, x2)                        \
+  {                                                                     \
+    sig = new SC_OUT (Tcontrol_t) ** [x1];                              \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_OUT (Tcontrol_t) * [x2];                     \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = interface[it1][it2]->set_signal_valack_out (type); \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC2_SIGNAL_IN( sig, name, type, size, x1, x2)               \
+  {                                                                     \
+    sig = new SC_IN (type) ** [x1];                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_IN (type) * [x2];                            \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            if (size > 0)                                               \
+              {                                                         \
+                sig [it1][it2] = interface[it1][it2]->set_signal_in <type> (name, size); \
+              }                                                         \
+            else                                                        \
+              {                                                         \
+                PRINT_SIZE_NUL(_component,interface[it1][it2],name);    \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC2_SIGNAL_OUT( sig, name, type, size, x1, x2)              \
+  {                                                                     \
+    sig = new SC_OUT (type) ** [x1];                                    \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_OUT (type) * [x2];                           \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            if (size > 0)                                               \
+              {                                                         \
+                sig [it1][it2] = interface[it1][it2]->set_signal_out <type> (name, size); \
+              }                                                         \
+            else                                                        \
+              {                                                         \
+                PRINT_SIZE_NUL(_component,interface[it1][it2],name);    \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
 …
 #define ALLOC2_SIGNAL_OUT( sig, name, type, size) _ALLOC2_SIGNAL_OUT( sig, name, type, size, iterator_1, iterator_2)
+#define DELETE2_SIGNAL(sig, it1,it2, size)                              \
+  {                                                                     \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+      {                                                                 \
+        for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
+          {                                                             \
+            if (size > 0)                                               \
+              {                                                         \
+                delete sig[alloc_signal_it1][alloc_signal_it2];         \
+              }                                                         \
+          }                                                             \
+        delete [] sig[alloc_signal_it1];                                \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#define ALLOC2_SC_SIGNAL( sig, name, type, it1, it2)                    \
+  sc_signal<type> *** sig = new sc_signal<type> ** [it1];               \
+  {                                                                     \
+    std::string separator="_";                                          \
+    std::string str;                                                    \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+      {                                                                 \
+        sig [alloc_signal_it1] = new sc_signal<type> * [it2];           \
+        for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
+          {                                                             \
+            str = name+separator+toString(alloc_signal_it1)+separator+toString(alloc_signal_it2); \
+            sig [alloc_signal_it1][alloc_signal_it2] = new sc_signal<type> (str.c_str()); \
+          }                                                             \
+      }                                                                 \
+  }
+#define INSTANCE2_SC_SIGNAL(component, sig, it1, it2)                   \
+  for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+    for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
+      {                                                                 \
+        TEST_PTR(component->sig [alloc_signal_it1][alloc_signal_it2]);  \
+        TEST_PTR(sig            [alloc_signal_it1][alloc_signal_it2]);  \
+        (*(component->sig[alloc_signal_it1][alloc_signal_it2])) (*(sig[alloc_signal_it1][alloc_signal_it2])); \
+#define DELETE2_SIGNAL(sig, x1,x2, size)                                \
+  {                                                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            if (size > 0)                                               \
+              {                                                         \
+                delete sig[it1][it2];                                   \
+              }                                                         \
+          }                                                             \
+        delete [] sig[it1];                                             \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#define ALLOC2_SC_SIGNAL( sig, name, type, x1, x2)                      \
+  sc_signal<type> *** sig = new sc_signal<type> ** [x1];                \
+  {                                                                     \
+    std::string separator="_";                                          \
+    std::string str;                                                    \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new sc_signal<type> * [x2];                         \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            str = name+separator+toString(it1)+separator+toString(it2); \
+            sig [it1][it2] = new sc_signal<type> (str.c_str());         \
+            PRINT_SIGNAL_ADDRESS(str.c_str(),sig[it1][it2]);            \
+          }                                                             \
+      }                                                                 \
+  }
+#define INSTANCE2_SC_SIGNAL(component, sig, x1, x2)                     \
+  for (uint32_t it1=0; it1<x1; it1++)                                   \
+    for (uint32_t it2=0; it2<x2; it2++)                                 \
+      {                                                                 \
+        TEST_SIGNAL(component->sig  [it1][it2]->name(),component->sig  [it1][it2]); \
+        TEST_SIGNAL(sig             [it1][it2]->name(),sig             [it1][it2]); \
+        (*(component->sig[it1][it2])) (*(sig[it1][it2]));               \
+      }
+#define DELETE2_SC_SIGNAL(sig,it1,it2)                                  \
+  {                                                                     \
+    for (uint32_t alloc_signal_it1=0; alloc_signal_it1<it1; alloc_signal_it1++) \
+      {                                                                 \
+        for (uint32_t alloc_signal_it2=0; alloc_signal_it2<it2; alloc_signal_it2++) \
+          {                                                             \
+            delete sig[alloc_signal_it1][alloc_signal_it2];             \
+          }                                                             \
+        delete [] sig[alloc_signal_it1];                                \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#define _INSTANCE2_SC_SIGNAL(component, sig1, sig2, x1, x2)             \
+  for (uint32_t it1=0; it1<x1; it1++)                                   \
+    for (uint32_t it2=0; it2<x2; it2++)                                 \
+      {                                                                 \
+        TEST_SIGNAL(component->sig1 [it1][it2]->name(),component->sig1 [it1][it2]); \
+        TEST_SIGNAL(sig2            [it1][it2]->name(),sig2            [it1][it2]); \
+        (*(component->sig1[it1][it2])) (*(sig2[it1][it2]));             \
+      }
+#define DELETE2_SC_SIGNAL(sig,x1,x2)                                    \
+  {                                                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            delete sig[it1][it2];                                       \
+          }                                                             \
+        delete [] sig[it1];                                             \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+// ----------------------------------------------------------------------
+// -----[ ITERATION 3 ]--------------------------------------------------
+// ----------------------------------------------------------------------
+#ifdef POSITION
+#define ALLOC3_INTERFACE( name, direction, localisation, str, x1, x2, x3) \
+  INTERFACE_PRINT(name);                                                \
+  uint32_t iterator_1 = 0;                                              \
+  uint32_t iterator_2 = 0;                                              \
+  uint32_t iterator_3 = 0;                                              \
+  morpheo::behavioural::Interface_fifo **** interface;                  \
+  {                                                                     \
+    std::string separator="_";                                          \
+    iterator_1 = x1;                                                    \
+    interface = new morpheo::behavioural::Interface_fifo *** [iterator_1]; \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        iterator_2 = x2;                                                \
+        interface [it1] = new morpheo::behavioural::Interface_fifo ** [iterator_2]; \
+        for (uint32_t it2=0; it2<iterator_2; it2++)                     \
+          {                                                             \
+            iterator_3 = x3;                                            \
+            interface [it1][it2] = new morpheo::behavioural::Interface_fifo * [iterator_3]; \
+            for (uint32_t it3=0; it3<iterator_3; it3++)                 \
+              {                                                         \
+                interface [it1][it2][it3] = _interfaces->set_interface( name+separator+toString(it1)+separator+toString(it2)+separator+toString(it3), direction, localisation, str); \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
+#else
+#define ALLOC3_INTERFACE( name, direction, localisation, str, x1, x2, x3) \
+  INTERFACE_PRINT(name);                                                \
+  uint32_t iterator_1 = 0;                                              \
+  uint32_t iterator_2 = 0;                                              \
+  uint32_t iterator_3 = 0;                                              \
+  morpheo::behavioural::Interface_fifo **** interface;                  \
+  {                                                                     \
+    std::string separator="_";                                          \
+    iterator_1 = x1;                                                    \
+    interface = new morpheo::behavioural::Interface_fifo *** [iterator_1]; \
+    for (uint32_t it1=0; it1<iterator_1; it1++)                         \
+      {                                                                 \
+        iterator_2 = x2;                                                \
+        interface [it1] = new morpheo::behavioural::Interface_fifo ** [iterator_2]; \
+        for (uint32_t it2=0; it2<iterator_2; it2++)                     \
+          {                                                             \
+            iterator_3 = x3;                                            \
+            interface [it1][it2] = new morpheo::behavioural::Interface_fifo * [iterator_3]; \
+            for (uint32_t it3=0; it3<iterator_3; it3++)                 \
+              {                                                         \
+                interface [it1][it2][it3] = _interfaces->set_interface( name+separator+toString(it1)+separator+toString(it2)+separator+toString(it3)); \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
 #endif
+// #define _ALLOC3_VAL_ACK_IN( sig, name, type, x1, x2, x3)
+// #define _ALLOC3_VAL_ACK_OUT( sig, name, type, x1, x2, x3)
+#define _ALLOC3_VALACK_IN(    sig,type, x1, x2, x3)                     \
+  {                                                                     \
+    sig = new SC_IN (Tcontrol_t) *** [x1];                              \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_IN (Tcontrol_t) ** [x2];                     \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = new SC_IN (Tcontrol_t) * [x3];             \
+            for (uint32_t it3=0; it3<x3; it3++)                         \
+              {                                                         \
+                sig [it1][it2][it3] = interface[it1][it2][it3]->set_signal_valack_in (type); \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC3_VALACK_OUT(    sig,type, x1, x2, x3)                    \
+  {                                                                     \
+    sig = new SC_OUT (Tcontrol_t) *** [x1];                             \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_OUT (Tcontrol_t) ** [x2];                    \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = new SC_OUT (Tcontrol_t) * [x3];            \
+            for (uint32_t it3=0; it3<x3; it3++)                         \
+              {                                                         \
+                sig [it1][it2][it3] = interface[it1][it2][it3]->set_signal_valack_out (type); \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC3_SIGNAL_IN( sig, name, type, size, x1, x2,x3)            \
+  {                                                                     \
+    sig = new SC_IN (type) *** [x1];                                    \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_IN (type) ** [x2];                           \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = new SC_IN (type) * [x3];                   \
+            for (uint32_t it3=0; it3<x3; it3++)                         \
+              {                                                         \
+                if (size > 0)                                           \
+                  {                                                     \
+                    sig [it1][it2][it3] = interface[it1][it2][it3]->set_signal_in <type> (name, size); \
+                  }                                                     \
+                else                                                    \
+                  {                                                     \
+                    PRINT_SIZE_NUL(_component,interface[it1][it2][it3],name); \
+                  }                                                     \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
+#define _ALLOC3_SIGNAL_OUT( sig, name, type, size, x1, x2,x3)           \
+  {                                                                     \
+    sig = new SC_OUT (type) *** [x1];                                   \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        sig [it1] = new SC_OUT (type) ** [x2];                          \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            sig [it1][it2] = new SC_OUT (type) * [x3];                  \
+            for (uint32_t it3=0; it3<x3; it3++)                         \
+              {                                                         \
+                if (size > 0)                                           \
+                  {                                                     \
+                    sig [it1][it2][it3] = interface[it1][it2][it3]->set_signal_out <type> (name, size); \
+                  }                                                     \
+                else                                                    \
+                  {                                                     \
+                    PRINT_SIZE_NUL(_component,interface[it1][it2][it3],name); \
+                  }                                                     \
+              }                                                         \
+          }                                                             \
+      }                                                                 \
+  }
+// #define ALLOC3_VAL_ACK_IN( sig, name, type      ) _ALLOC3_VAL_ACK_IN( sig, name, type      , iterator_1, iterator_2, iterator_3)
+// #define ALLOC3_VAL_ACK_OUT(sig, name, type      ) _ALLOC3_VAL_ACK_OUT(sig, name, type      , iterator_1, iterator_2, iterator_3)
+#define ALLOC3_VALACK_IN(  sig,       type      ) _ALLOC3_VALACK_IN(  sig,       type      , iterator_1, iterator_2, iterator_3)
+#define ALLOC3_VALACK_OUT( sig,       type      ) _ALLOC3_VALACK_OUT( sig,       type      , iterator_1, iterator_2, iterator_3)
+#define ALLOC3_SIGNAL_IN(  sig, name, type, size) _ALLOC3_SIGNAL_IN(  sig, name, type, size, iterator_1, iterator_2, iterator_3)
+#define ALLOC3_SIGNAL_OUT( sig, name, type, size) _ALLOC3_SIGNAL_OUT( sig, name, type, size, iterator_1, iterator_2, iterator_3)
+#define DELETE3_SIGNAL(sig, x1, x2, x3, size)                           \
+  {                                                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            for (uint32_t it3=0; it3<x3; it3++)                         \
+              {                                                         \
+                if (size > 0)                                           \
+                  {                                                     \
+                    delete sig[it1][it2][it3];                          \
+                  }                                                     \
+              }                                                         \
+            delete [] sig[it1][it2];                                    \
+          }                                                             \
+        delete [] sig[it1];                                             \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#define ALLOC3_SC_SIGNAL( sig, name, type, x1, x2, x3)                  \
+  sc_signal<type> **** sig = new sc_signal<type> *** [x1];              \
+  {                                                                     \
+    std::string separator="_";                                          \
+    std::string str;                                                    \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+         sig [it1] = new sc_signal<type> ** [x2];                       \
+         for (uint32_t it2=0; it2<x2; it2++)                            \
+           {                                                            \
+              sig [it1][it2] = new sc_signal<type> * [x3];              \
+              for (uint32_t it3=0; it3<x3; it3++)                       \
+                {                                                       \
+                  str = name+separator+toString(it1)+separator+toString(it2)+separator+toString(it3); \
+                  sig [it1][it2][it3] = new sc_signal<type> (str.c_str()); \
+                  PRINT_SIGNAL_ADDRESS(str.c_str(),sig[it1][it2][it3]); \
+                }                                                       \
+           }                                                            \
+      }                                                                 \
+  }
+#define INSTANCE3_SC_SIGNAL(component, sig, x1, x2, x3)                 \
+  for (uint32_t it1=0; it1<x1; it1++)                                   \
+    for (uint32_t it2=0; it2<x2; it2++)                                 \
+      for (uint32_t it3=0; it3<x3; it3++)                               \
+        {                                                               \
+          TEST_SIGNAL(component->sig  [it1][it2][it3]->name(),component->sig  [it1][it2][it3]); \
+          TEST_SIGNAL(sig             [it1][it2][it3]->name(),sig             [it1][it2][it3]); \
+          (*(component->sig[it1][it2][it3])) (*(sig[it1][it2][it3]));   \
+        }
+#define _INSTANCE3_SC_SIGNAL(component, sig1, sig2, x1, x2, x3)         \
+  for (uint32_t it1=0; it1<x1; it1++)                                   \
+    for (uint32_t it2=0; it2<x2; it2++)                                 \
+      for (uint32_t it3=0; it3<x3; it3++)                               \
+        {                                                               \
+          TEST_SIGNAL(component->sig1 [it1][it2][it3]->name(),component->sig1 [it1][it2][it3]); \
+          TEST_SIGNAL(sig2            [it1][it2][it3]->name(),sig2            [it1][it2][it3]); \
+          (*(component->sig1[it1][it2][it3])) (*(sig2[it1][it2][it3])); \
+        }
+#define DELETE3_SC_SIGNAL(sig,x1,x2,x3)                                 \
+  {                                                                     \
+    for (uint32_t it1=0; it1<x1; it1++)                                 \
+      {                                                                 \
+        for (uint32_t it2=0; it2<x2; it2++)                             \
+          {                                                             \
+            for (uint32_t it3=0; it3<x3; it3++)                         \
+              {                                                         \
+                delete sig[it1][it2][it3];                              \
+              }                                                         \
+            delete [] sig[it1][it2];                                    \
+          }                                                             \
+        delete [] sig[it1];                                             \
+      }                                                                 \
+    delete [] sig;                                                      \
+  }
+#endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Constants.h

-              r81
+              r88
 #define morpheo_behavioural_Constants_h
+/*
+  WARNING :
+  I Use reserved exception :
+x10 - EXCEPTION_MEMORY_MISS_SPECULATION   - Load miss speculation
+x11 - EXCEPTION_MEMORY_LOAD_SPECULATIVE   - The load is speculative : write in register file, but don't commit
+x12 - EXCEPTION_ALU_SPR_ACCESS_INVALID    - SPR     present in ALU but not compatible privilege
+x13 - EXCEPTION_ALU_SPR_ACCESS_MUST_READ  - SPR not present in ALU
+x14 - EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE - SPR not present in ALU
+  I Use reserved SPR :
+  [0][19] - SPR_CID
+*/
 namespace morpheo {
 namespace behavioural {
+#  define SET_FLAG(     x,pos)  {(x) |=  (1<<(pos));} while (0)
+#  define UNSET_FLAG(   x,pos)  {(x) &= ~(1<<(pos));} while (0)
+#  define IS_SET_FLAG(  x,pos) (((x) &   (1<<(pos))) != 0)
+#  define IS_UNSET_FLAG(x,pos) (((x) &   (1<<(pos))) == 0)
+#  define CHANGE_FLAG(  x,pos,f) \
+   {                        \
+     if (f)                 \
+       {SET_FLAG(x,pos);}   \
+     else                   \
+       {UNSET_FLAG(x,pos);} \
+   } while (0)
   //=========================================================[ Type ]=====
 …
 #  define TYPE_MOVE                                0x2        // 00000 - unit multiple
 #  define TYPE_TEST                                0x3        // 00000 - unit multiple
+#  define TYPE_MUL_DIV                             0x4        // 00000 - unit multiple
+#  define TYPE_EXTEND                              0x5        // 00000 - unit multiple, type optionnal
+#  define TYPE_FIND                                0x6        // 00000 - unit multiple, type optionnal
+#  define TYPE_SPECIAL                             0x7        // 00000 - unit uniq
+#  define TYPE_CUSTOM                              0x8        // 00000 - unit uniq    , type optionnal
+#  define TYPE_BRANCH                              0x9        // 00000 - unit multiple
+#  define TYPE_MEMORY                              0xa        // 00000 - unit uniq
+#  define TYPE_MUL                                 0x4        // 00000 - unit multiple
+#  define TYPE_DIV                                 0x5        // 00000 - unit multiple, type optionnal
+#  define TYPE_EXTEND                              0x6        // 00000 - unit multiple, type optionnal
+#  define TYPE_FIND                                0x7        // 00000 - unit multiple, type optionnal
+#  define TYPE_SPECIAL                             0x8        // 00000 - unit uniq
+#  define TYPE_CUSTOM                              0x9        // 00000 - unit uniq    , type optionnal
+#  define TYPE_BRANCH                              0xa        // 00000 - unit multiple
+#  define TYPE_MEMORY                              0xb        // 00000 - unit uniq
+//#define NB_TYPE                                  11
 #  define SIZE_TYPE                                5
 #  define MAX_TYPE                                 (1<<SIZE_TYPE)
+#  define is_type_valid(x) \
+  (( x == TYPE_ALU    ) or \
+   ( x == TYPE_SHIFT  ) or \
+   ( x == TYPE_MOVE   ) or \
+   ( x == TYPE_TEST   ) or \
+   ( x == TYPE_MUL    ) or \
+   ( x == TYPE_DIV    ) or \
+   ( x == TYPE_EXTEND ) or \
+   ( x == TYPE_FIND   ) or \
+   ( x == TYPE_SPECIAL) or \
+   ( x == TYPE_CUSTOM ) or \
+   ( x == TYPE_BRANCH ) or \
+   ( x == TYPE_MEMORY ))
   //====================================================[ Operation ]=====
 …
 #  define OPERATION_TEST_L_SFNE                    0x20       // 000_0000 l.sfne  , l.sfnei
+#  define OPERATION_MUL_DIV_L_MUL                  0x1        // 000_0000 l.mul   , l.muli
+#  define OPERATION_MUL_DIV_L_MULU                 0x2        // 000_0000 l.mulu
+#  define OPERATION_MUL_DIV_L_DIV                  0x4        // 000_0000 l.div
+#  define OPERATION_MUL_DIV_L_DIVU                 0x8        // 000_0000 l.divu
+#  define OPERATION_MUL_L_MUL                      0x1        // 000_0000 l.mul   , l.muli
+#  define OPERATION_MUL_L_MULU                     0x2        // 000_0000 l.mulu
+#  define OPERATION_DIV_L_DIV                      0x1        // 000_0000 l.div
+#  define OPERATION_DIV_L_DIVU                     0x2        // 000_0000 l.divu
 #  define OPERATION_EXTEND_L_EXTEND_Z              0x1        // 000_0000 l.extbz , l.exthz, l.extwz
 …
 #  define SIZE_EXCEPTION                           5
 #  define SIZE_EXCEPTION_USE                       4
 #  define SIZE_EXCEPTION_MEMORY                    3
 #  define SIZE_EXCEPTION_CUSTOM                    3
 #  define SIZE_EXCEPTION_ALU                       2
 #  define SIZE_EXCEPTION_DECOD                     2
 #  define SIZE_EXCEPTION_IFETCH                    2
+#  define SIZE_EXCEPTION_MEMORY                    5
+#  define SIZE_EXCEPTION_CUSTOM                    5
+#  define SIZE_EXCEPTION_ALU                       5
+#  define SIZE_EXCEPTION_DECOD                     5
+#  define SIZE_EXCEPTION_IFETCH                    5
 #  define EXCEPTION_NONE                           0x00       // none exception
 …
 #  define EXCEPTION_CUSTOM_6                       0x1f       // Reserved for custom exceptions
+#define exception_to_address(x) (x<<8)
+  //SR[14].EPH : Exception Prefix High
+  // EPH = 0 Exceptions vectors are located in memory area starting at 0x0
+  // EPH = 1 Exception vectors are located in memory area starting at 0xF0000000
+#define exception_to_address(eph,x) (((eph==0)?0x0:0xF0000000)+(x<<8))
   // Exception Execution
+#  define EXCEPTION_MEMORY_NONE                    0x0        // Load/Store generate none exception
+#  define EXCEPTION_MEMORY_ALIGNMENT               0x1        // Load/Store access is not aligned
+#  define EXCEPTION_MEMORY_DATA_TLB                0x2        // DTLB miss
+#  define EXCEPTION_MEMORY_DATA_PAGE               0x3        // No matching or page violation protection in pages tables
+#  define EXCEPTION_MEMORY_BUS_ERROR               0x4        // Access at a invalid physical address
+#  define EXCEPTION_MEMORY_MISS_SPECULATION        0x5        // Load miss speculation
+#  define EXCEPTION_MEMORY_LOAD_SPECULATIVE        0x6        // The load is speculative : write in register file, but don't commit
+#  define EXCEPTION_CUSTOM_NONE                    0x1        // Custom unit generate none exception
+#  define EXCEPTION_CUSTOM_CUST_0                  0x1        // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_1                  0x2        // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_2                  0x3        // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_3                  0x4        // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_4                  0x5        // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_5                  0x6        // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_6                  0x7        // Reserved for custom exceptions
+#  define EXCEPTION_ALU_NONE                       0x0        // Functionnal unit generate none exception
+#  define EXCEPTION_ALU_RANGE                      0x1        //
+#  define EXCEPTION_ALU_SPR_ACCESS_INVALID         0x2        // SPR     present in ALU but not compatible privilege
+#  define EXCEPTION_ALU_SPR_ACCESS_NOT_COMPLETE    0x3        // SPR not present in ALU
+#  define EXCEPTION_DECOD_NONE                     0x0        // none exception
+#  define EXCEPTION_DECOD_ILLEGAL_INSTRUCTION      0x1        // Instruction is illegal (no implemented)
+#  define EXCEPTION_DECOD_SYSCALL                  0x2        // System Call
+//#define EXCEPTION_DECOD_TRAP                     0x4        // L.trap or debug unit (note : must read SR !)
+#  define EXCEPTION_IFETCH_NONE                    0x0        // Fetch Unit generate none exception
+#  define EXCEPTION_IFETCH_INSTRUCTION_TLB         0x1        // ITLB miss
+#  define EXCEPTION_IFETCH_INSTRUCTION_PAGE        0x2        // No matching or page violation protection in pages tables
+#  define EXCEPTION_IFETCH_BUS_ERROR               0x3        // Access at a invalid physical address
+#  define EXCEPTION_USE_NONE                       0x0        //
+#  define EXCEPTION_USE_ILLEGAL_INSTRUCTION        0x1        // illegal_instruction
+#  define EXCEPTION_USE_RANGE                      0x2        // range
+#  define EXCEPTION_USE_MEMORY_WITH_ALIGNMENT      0x3        // TLB miss, page fault, bus error, alignment
+#  define EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT   0x4        // TLB miss, page fault, bus error
+#  define EXCEPTION_USE_SYSCALL                    0x5        // syscall
+#  define EXCEPTION_USE_TRAP                       0x6        // trap
+#  define EXCEPTION_USE_CUSTOM_0                   0x7        //
+#  define EXCEPTION_USE_CUSTOM_1                   0x8        //
+#  define EXCEPTION_USE_CUSTOM_2                   0x9        //
+#  define EXCEPTION_USE_CUSTOM_3                   0xa        //
+#  define EXCEPTION_USE_CUSTOM_4                   0xb        //
+#  define EXCEPTION_USE_CUSTOM_5                   0xc        //
+#  define EXCEPTION_USE_CUSTOM_6                   0xd        //
+#  define EXCEPTION_IFETCH_NONE                    0x00       // Fetch Unit generate none exception
+#  define EXCEPTION_IFETCH_INSTRUCTION_TLB         0x0a       // ITLB miss
+#  define EXCEPTION_IFETCH_INSTRUCTION_PAGE        0x04       // No matching or page violation protection in pages tables
+#  define EXCEPTION_IFETCH_BUS_ERROR               0x02       // Access at a invalid physical address
+#  define EXCEPTION_DECOD_NONE                     0x00       // none exception
+#  define EXCEPTION_DECOD_ILLEGAL_INSTRUCTION      0x01       // Instruction is illegal (no implemented)
+#  define EXCEPTION_DECOD_SYSCALL                  0x02       // System Call
+//#define EXCEPTION_DECOD_TRAP                     0x0e       // L.trap or debug unit (note : must read SR !)
+#  define EXCEPTION_DECOD_INSTRUCTION_TLB          0x0a       // ITLB miss
+#  define EXCEPTION_DECOD_INSTRUCTION_PAGE         0x04       // No matching or page violation protection in pages tables
+#  define EXCEPTION_DECOD_BUS_ERROR                0x02       // Access at a invalid physical address
+#  define EXCEPTION_ALU_NONE                       0x00       // Functionnal unit generate none exception
+#  define EXCEPTION_ALU_RANGE                      0x0b       //
+#  define EXCEPTION_ALU_SPR_ACCESS_INVALID         0x12       // SPR     present in ALU but not compatible privilege
+#  define EXCEPTION_ALU_SPR_ACCESS_MUST_READ       0x13       // SPR not present in ALU
+#  define EXCEPTION_ALU_SPR_ACCESS_MUST_WRITE      0x14       // SPR not present in ALU
+#  define EXCEPTION_MEMORY_NONE                    0x00       // Load/Store generate none exception
+#  define EXCEPTION_MEMORY_ALIGNMENT               0x06       // Load/Store access is not aligned
+#  define EXCEPTION_MEMORY_DATA_TLB                0x09       // DTLB miss
+#  define EXCEPTION_MEMORY_DATA_PAGE               0x03       // No matching or page violation protection in pages tables
+#  define EXCEPTION_MEMORY_BUS_ERROR               0x02       // Access at a invalid physical address
+#  define EXCEPTION_MEMORY_MISS_SPECULATION        0x10       // Load miss speculation
+#  define EXCEPTION_MEMORY_LOAD_SPECULATIVE        0x11       // The load is speculative : write in register file, but don't commit
+#  define EXCEPTION_CUSTOM_NONE                    0x00       // Custom unit generate none exception
+#  define EXCEPTION_CUSTOM_CUST_0                  0x19       // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_1                  0x1a       // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_2                  0x1b       // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_3                  0x1c       // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_4                  0x1d       // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_5                  0x1e       // Reserved for custom exceptions
+#  define EXCEPTION_CUSTOM_CUST_6                  0x1f       // Reserved for custom exceptions
+#  define EXCEPTION_USE_NONE                       0x00       //
+#  define EXCEPTION_USE_ILLEGAL_INSTRUCTION        0x01       // illegal_instruction
+#  define EXCEPTION_USE_RANGE                      0x02       // range
+#  define EXCEPTION_USE_MEMORY_WITH_ALIGNMENT      0x03       // TLB miss, page fault, bus error, alignment
+#  define EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT   0x04       // TLB miss, page fault, bus error
+#  define EXCEPTION_USE_SYSCALL                    0x05       // syscall
+#  define EXCEPTION_USE_TRAP                       0x06       // trap
+#  define EXCEPTION_USE_CUSTOM_0                   0x07       //
+#  define EXCEPTION_USE_CUSTOM_1                   0x08       //
+#  define EXCEPTION_USE_CUSTOM_2                   0x09       //
+#  define EXCEPTION_USE_CUSTOM_3                   0x0a       //
+#  define EXCEPTION_USE_CUSTOM_4                   0x0b       //
+#  define EXCEPTION_USE_CUSTOM_5                   0x0c       //
+#  define EXCEPTION_USE_CUSTOM_6                   0x0d       //
+#  define exception_ifetch_to_exception_decod(x) x
+#  define exception_decod_to_exception(x)        x
+#  define exception_alu_to_exception(x)          x
+#  define exception_memory_to_exception(x)       x
+#  define exception_custom_to_exception(x)       x
   //=======================================================[ icache ]=====
 …
   //--------------------------------------------------[ icache_type ]-----
 #  define SIZE_ICACHE_TYPE                              2
 #  define ICACHE_TYPE_LOAD                              0x0        // 0000
 #  define ICACHE_TYPE_LOCK                              0x1        // 0001
 #  define ICACHE_TYPE_INVALIDATE                        0x2        // 0010
 #  define ICACHE_TYPE_PREFETCH                          0x3        // 0011
+#  define SIZE_ICACHE_TYPE                         2
+#  define ICACHE_TYPE_LOAD                         0x0        // 0000
+#  define ICACHE_TYPE_LOCK                         0x1        // 0001
+#  define ICACHE_TYPE_INVALIDATE                   0x2        // 0010
+#  define ICACHE_TYPE_PREFETCH                     0x3        // 0011
 // just take the 2 less significative bits.
 …
   //-------------------------------------------------[ icache_error ]-----
 #  define SIZE_ICACHE_ERROR                             1
 #  define ICACHE_ERROR_NONE                             0x0
 #  define ICACHE_ERROR_BUS_ERROR                        0x1
+#  define SIZE_ICACHE_ERROR                        1
+#  define ICACHE_ERROR_NONE                        0x0
+#  define ICACHE_ERROR_BUS_ERROR                   0x1
   //=======================================================[ dcache ]=====
 …
   //--------------------------------------------------[ dcache_type ]-----
 #  define SIZE_DCACHE_TYPE                              4
 //#define DCACHE_TYPE_                                  0x0        // 0000
 #  define DCACHE_TYPE_LOCK                              0x1        // 0001
 #  define DCACHE_TYPE_INVALIDATE                        0x2        // 0010
 #  define DCACHE_TYPE_PREFETCH                          0x3        // 0011
 //#define DCACHE_TYPE_                                  0x4        // 0100
 //#define DCACHE_TYPE_                                  0x5        // 0101
 #  define DCACHE_TYPE_FLUSH                             0x6        // 0110
 #  define DCACHE_TYPE_SYNCHRONIZATION                   0x7        // 0111
 #  define DCACHE_TYPE_LOAD_8                            0x8        // 1000
 #  define DCACHE_TYPE_LOAD_16                           0x9        // 1001
 #  define DCACHE_TYPE_LOAD_32                           0xa        // 1010
 #  define DCACHE_TYPE_LOAD_64                           0xb        // 1011
 #  define DCACHE_TYPE_STORE_8                           0xc        // 1100
 #  define DCACHE_TYPE_STORE_16                          0xd        // 1101
 #  define DCACHE_TYPE_STORE_32                          0xe        // 1110
 #  define DCACHE_TYPE_STORE_64                          0xf        // 1111
+#  define SIZE_DCACHE_TYPE                         4
+//#define DCACHE_TYPE_                             0x0        // 0000
+#  define DCACHE_TYPE_LOCK                         0x1        // 0001
+#  define DCACHE_TYPE_INVALIDATE                   0x2        // 0010
+#  define DCACHE_TYPE_PREFETCH                     0x3        // 0011
+//#define DCACHE_TYPE_                             0x4        // 0100
+//#define DCACHE_TYPE_                             0x5        // 0101
+#  define DCACHE_TYPE_FLUSH                        0x6        // 0110
+#  define DCACHE_TYPE_SYNCHRONIZATION              0x7        // 0111
+#  define DCACHE_TYPE_LOAD_8                       0x8        // 1000
+#  define DCACHE_TYPE_LOAD_16                      0x9        // 1001
+#  define DCACHE_TYPE_LOAD_32                      0xa        // 1010
+#  define DCACHE_TYPE_LOAD_64                      0xb        // 1011
+#  define DCACHE_TYPE_STORE_8                      0xc        // 1100
+#  define DCACHE_TYPE_STORE_16                     0xd        // 1101
+#  define DCACHE_TYPE_STORE_32                     0xe        // 1110
+#  define DCACHE_TYPE_STORE_64                     0xf        // 1111
 // just take the 4 less significative bits.
 …
   //-------------------------------------------------[ dcache_error ]-----
 #  define SIZE_DCACHE_ERROR                             1
 #  define DCACHE_ERROR_NONE                             0x0
 #  define DCACHE_ERROR_BUS_ERROR                        0x1
+#  define SIZE_DCACHE_ERROR                        1
+#  define DCACHE_ERROR_NONE                        0x0
+#  define DCACHE_ERROR_BUS_ERROR                   0x1
   //=================================================[ special_data ]=====
 #  define SIZE_SPECIAL_DATA                             2
+#  define SIZE_SPECIAL_DATA                        2
 // Position of flag in "rename register SR" (NOT IN "SR")
 #  define FLAG_POSITION_F                               0x0         // Conditionnal branch flag
 #  define FLAG_POSITION_CY                              0x1         // Carry was produced by last arithmetic operation
 #  define FLAG_POSITION_OV                              0x0         // Overflow occured during last arithmetic operation
 #  define FLAG_F                                        (1<<FLAG_POSITION_F ) // Conditionnal branch flag
 #  define FLAG_CY                                       (1<<FLAG_POSITION_CY) // Carry was produced by last arithmetic operation
 #  define FLAG_OV                                       (1<<FLAG_POSITION_OV) // Overflow occured during last arithmetic operation
+#  define FLAG_POSITION_F                          0x0         // Conditionnal branch flag
+#  define FLAG_POSITION_CY                         0x1         // Carry was produced by last arithmetic operation
+#  define FLAG_POSITION_OV                         0x0         // Overflow occured during last arithmetic operation
+#  define FLAG_F                                   (1<<FLAG_POSITION_F ) // Conditionnal branch flag
+#  define FLAG_CY                                  (1<<FLAG_POSITION_CY) // Carry was produced by last arithmetic operation
+#  define FLAG_OV                                  (1<<FLAG_POSITION_OV) // Overflow occured during last arithmetic operation
   //==========================================================[ spr ]=====
 …
       GROUP_CUSTOM_6,            // 29
       GROUP_CUSTOM_7,            // 30
+      GROUP_CUSTOM_8             // 31
+      GROUP_CUSTOM_8,            // 31
+      NB_GROUP
     };
-#  define NB_GROUP                                 32
 #  define NB_REG_GROUP_SYSTEM_AND_CONTROL          1536
 #  define NB_REG_GROUP_DMMU                        1536
 …
 #  define NB_REG_GROUP_CUSTOM_7                    0
 #  define NB_REG_GROUP_CUSTOM_8                    0
+  static const uint32_t NB_REG_GROUP [] =
+    {NB_REG_GROUP_SYSTEM_AND_CONTROL  ,
+     NB_REG_GROUP_DMMU                ,
+     NB_REG_GROUP_IMMU                ,
+     NB_REG_GROUP_DCACHE              ,
+     NB_REG_GROUP_ICACHE              ,
+     NB_REG_GROUP_MAC                 ,
+     NB_REG_GROUP_DEBUG               ,
+     NB_REG_GROUP_PERFORMANCE_COUNTER ,
+     NB_REG_GROUP_POWER_MANAGEMENT    ,
+     NB_REG_GROUP_PIC                 ,
+     NB_REG_GROUP_TICK_TIMER          ,
+     NB_REG_GROUP_FLOATING_POINT      ,
+     NB_REG_GROUP_RESERVED_1          ,
+     NB_REG_GROUP_RESERVED_2          ,
+     NB_REG_GROUP_RESERVED_3          ,
+     NB_REG_GROUP_RESERVED_4          ,
+     NB_REG_GROUP_RESERVED_5          ,
+     NB_REG_GROUP_RESERVED_6          ,
+     NB_REG_GROUP_RESERVED_7          ,
+     NB_REG_GROUP_RESERVED_8          ,
+     NB_REG_GROUP_RESERVED_9          ,
+     NB_REG_GROUP_RESERVED_10         ,
+     NB_REG_GROUP_RESERVED_11         ,
+     NB_REG_GROUP_RESERVED_12         ,
+     NB_REG_GROUP_CUSTOM_1            ,
+     NB_REG_GROUP_CUSTOM_2            ,
+     NB_REG_GROUP_CUSTOM_3            ,
+     NB_REG_GROUP_CUSTOM_4            ,
+     NB_REG_GROUP_CUSTOM_5            ,
+     NB_REG_GROUP_CUSTOM_6            ,
+     NB_REG_GROUP_CUSTOM_7            ,
+     NB_REG_GROUP_CUSTOM_8            };
+  // GROUP_SYSTEM_AND_CONTROL
+#  define SPR_VR                                   0          // Version register
+#  define SPR_UPR                                  1          // Unit Present register
+#  define SPR_CPUCFGR                              2          // CPU Configuration register
+#  define SPR_DMMUCFGR                             3          // Data MMU Configuration register
+#  define SPR_IMMUCFGR                             4          // Instruction MMU Configuration register
+#  define SPR_DCCFGR                               5          // Data Cache Configuration register
+#  define SPR_ICCFGR                               6          // Instruction Cache Configuration register
+#  define SPR_DCFGR                                7          // Debug Configuration register
+#  define SPR_PCCFGR                               8          // Performance Counters Configuration register
+#  define SPR_NPC                                  16         // PC mapped to SPR space (next PC)
+#  define SPR_SR                                   17         // Supervision register
+#  define SPR_PPC                                  18         // PC mapped to SPR space (previous PC)
+#  define SPR_CID                                  19         // Context Id
+#  define SPR_FPCSR                                20         // FP Control Status register
+#  define SPR_EPCR                                 32         // Exception PC register
+#  define SPR_EEAR                                 48         // Exception EA register
+#  define SPR_ESR                                  64         // Exception SR register
+#  define SPR_GPR                                  1024       // GPRs mappted to SPR space
+  // GROUP_DCACHE
+#  define SPR_DCCR                                 0          // DC Control register
+#  define SPR_DCBPR                                1          // DC Block Prefetch register
+#  define SPR_DCBFR                                2          // DC Block Flush register
+#  define SPR_DCBIR                                3          // DC Block Invalidate register
+#  define SPR_DCBWR                                4          // DC Block Write-back register
+#  define SPR_DCBLR                                5          // DC Block Lock register
+  // GROUP_ICACHE
+#  define SPR_ICCR                                 0          // IC Control register
+#  define SPR_ICBPR                                1          // IC Block Prefetch register
+#  define SPR_ICBIR                                2          // IC Block Invalidate register
+#  define SPR_ICBLR                                3          // IC Block Lock register
   // GROUP_MAC
 …
 #  define SPR_MACHI                                2          // MAC High
+  // SR RENAME
 #  define NB_SPR_LOGIC                             2
 #  define LOG2_NB_SPR_LOGIC                        1
 …
 #  define OPCOD_L_EXTWZ                            0x1           // 0001
-  /*
-  //--------------------------------------------------[ destination ]-----
-#define                 _size_destination1            4
-#define                  cst_DESTINATION1_NONE        0x0
-#define                 mask_DESTINATION1_GPR         0x1
-#define                 mask_DESTINATION1_MEMORY      0x2
-#define                 mask_DESTINATION1_SPR         0x4
-#define                 mask_DESTINATION1_MAC_UNIT    0x8
-#define                 _size_destination2  3
-#define                  cst_DESTINATION2_NONE        0x0
-#define                 mask_DESTINATION2_COMMIT      0x1
-#define                 mask_DESTINATION2_MEMORY      0x2
-#define                 mask_DESTINATION2_SPR         0x4
-  //----------------------------------------------------[ exec_flag ]-----
-#define                 _size_exec_flag               2
-#define                 mask_EXEC_FLAG_NONE           0x1
-#define                 mask_EXEC_FLAG_CARRY          0x1
-#define                 mask_EXEC_FLAG_FLAG           0x1
-#define                 mask_EXEC_FLAG_OVERFLOW       0x2
-  //---------------------------------------------------[ exec_excep ]-----
-#define                  _size_exec_excep             1
-#define                 mask_EXEC_EXCEP_NONE          0x0
-#define                 mask_EXEC_EXCEP_RANGE         0x1
-  //----------------------------------------------------[ Condition ]-----
-#define                 _size_condition               3
-#define                  cst_CONDITION_UNCONDITIONAL  0x0           // None condition (jump)
-#define                 mask_CONDITION_CONDITIONAL    0x2
-#define                 mask_CONDITION_CONDITIONAL_NF 0x0           // Branch if Flag is clear
-#define                 mask_CONDITION_CONDITIONAL_F  0x1           // Branch if Flag is set
-#define                 mask_CONDITION_REG            0x4           // Branch if a register is read
-#define                 mask_CONDITION_STACK          0x8           // Branch with pop  in stack pointer
-  */
-  /*
-#define M_CPU_SIZE_INST       32
-//----------------------------------------------------
-// Exception type
-//----------------------------------------------------
-#define M_CPU_LOG2_NB_EXCP    5
-#define M_CPU_NB_EXCP         32
-#define EXCP_NO               0x00          // none exception
-#define EXCP_RESET            0x01          // software or hardware reset
-#define EXCP_BERR             0x02          // Access at a invalid physical adress
-#define EXCP_D_PAGE           0x03          // No matching or page violation protection in pages tables
-#define EXCP_I_PAGE           0x04          // No matching or page violation protection in pages tables
-#define EXCP_TICK_TIMER       0x05          // Tick timer interruption
-#define EXCP_ALIGNMENT        0x06          // Load/Store access is not aligned
-#define EXCP_ILL_INST         0x07          // Instruction is illegal (no implemented)
-#define EXCP_IRQ              0x08          // External interruption
-#define EXCP_D_TLB            0x09          // DTLB miss
-#define EXCP_I_TLB            0x0a          // ITLB miss
-#define EXCP_RANGE            0x0b          // Overflow or access at a unimplemented register or context
-#define EXCP_SYSCALL          0x0c          // System Call
-#define EXCP_FP               0x0d          // Caused by a floating instruction
-#define EXCP_TRAP             0x0e          // L.trap or debug unit
-#define EXCP_RES0             0x0f          // Reserved for a futur usage
-#define EXCP_RES1             0x10          // Reserved for a futur usage
-#define EXCP_RES2             0x11          // Reserved for a futur usage
-#define EXCP_RES3             0x12          // Reserved for a futur usage
-#define EXCP_RES4             0x13          // Reserved for a futur usage
-#define EXCP_RES5             0x14          // Reserved for a futur usage
-#define EXCP_RES6             0x15          // Reserved for implemented specific exceptions
-#define EXCP_RES7             0x16          // Reserved for implemented specific exceptions
-#define EXCP_RES8             0x17          // Reserved for implemented specific exceptions
-#define EXCP_RES9             0x18          // Reserved for implemented specific exceptions
-#define EXCP_CUST0            0x19          // Reserved for custom exceptions
-#define EXCP_CUST1            0x1a          // Reserved for custom exceptions
-#define EXCP_CUST2            0x1b          // Reserved for custom exceptions
-#define EXCP_CUST3            0x1c          // Reserved for custom exceptions
-#define EXCP_CUST4            0x1d          // Reserved for custom exceptions
-#define EXCP_CUST5            0x1e          // Reserved for custom exceptions
-#define EXCP_CUST6            0x1f          // Reserved for custom exceptions
-//----------------------------------------------------
-// Flags
-//----------------------------------------------------
-#define M_CPU_NB_FLAG         3
-// Integer flags
-#define FLAG_F                0x1           // Conditionnal branch flag
-#define FLAG_CY               0x2           // Carry was produced by last arithmétic operation
-#define FLAG_OV               0x4           // Overflow occured during last arithmetic operation
-// Floating flags
-#define FLAG_OVF              0x004         // Overflow occured during last arithmetic operation
-#define FLAG_UNF              0x008         // Underflow flags
-#define FLAG_SNF              0x010         // Result SNAN
-#define FLAG_QNF              0x020         // Result QNAN
-#define FLAG_ZF               0x040         // Result is nul
-#define FLAG_IXF              0x080         // Result is inexact
-#define FLAG_IVF              0x100         // Result is invalid
-#define FLAG_INF              0x200         // Result is infinite
-#define FLAG_DZF              0x400         // Division by zero
-// Position of flag in "rename register SR" (NOT IN "SR")
-#define FLAG_POS_F            0x0           // Conditionnal branch flag
-#define FLAG_POS_CY           0x1           // Carry was produced by last arithmétic operation
-#define FLAG_POS_OV           0x0           // Overflow occured during last arithmetic operation
-//----------------------------------------------------
-// Instruction type
-//----------------------------------------------------
-#define M_CPU_LOG2_NB_TYPE    4
-#define TYPE_NOP              0x0
-#define TYPE_ALU_F            0x1           // Instruction ALU with    flag using (ADD, SUB, ADDC ...)
-#define TYPE_ALU_NF           0x2           // Instruction ALU without flag using (AND, OR ...)
-#define TYPE_MAC              0x3           // Instruction ALU with    utilisation of register HI/LO
-#define TYPE_J                0x4           // Branch instruction
-#define TYPE_SPR_READ         0x5           // Instruction special : l.mfspr
-#define TYPE_SPR_WRITE        0x6           // Instruction special : l.mtspr
-#define TYPE_SPECIAL          0x7           // Instruction execute in decode stage
-#define TYPE_CUSTOM           0x8           // Instruction Custom
-#define TYPE_LOAD_Z           0x9           // Load  access (extended by zero)
-#define TYPE_LOAD_S           0xa           // Load  access (sign extended)
-#define TYPE_STORE            0xc           // Store access
-//----------------------------------------------------
-// Condition to branch
-//----------------------------------------------------
-#define M_CPU_LOG2_NB_COND    4
-#define COND_NONE             0x0           // None condition (jump)
-#define COND_F                0x2           // Branch if Flag is set
-#define COND_NF               0x3           // Branch if Flag is clear
-#define COND_REG              0x4           // Branch if a register is read
-#define COND_STACK            0x8           // Branch with pop  in stack pointer
-//----------------------------------------------------
-// Event : State and Type
-//----------------------------------------------------
-#define EVENT_STATE_NO_EVENT  0             // no event : current case
-#define EVENT_STATE_EVENT     1             // Have a event : make necessary to manage the event
-#define EVENT_STATE_WAITEND   2             // Wait end of manage event (restaure a good context)
-#define EVENT_STATE_END       3             // CPU can continue
-#define EVENT_TYPE_MISS       0             // miss of speculation
-#define EVENT_TYPE_EXCP       1             // exception or interruption occure
-// SPEC? TAKE?
-#define BRANCH_STATE_NONE         0  // 0     0
-#define BRANCH_STATE_NSPEC_TAKE   1  // 0     1  -> incondionnal
-#define BRANCH_STATE_SPEC_NTAKE   2  // 1     0
-#define BRANCH_STATE_SPEC_TAKE    3  // 1     1
-//----------------------------------------------------
-// Name to particular register
-//----------------------------------------------------
-//~~~~~~~~~~~~~~~~~~~~~~~~~~
-// GENERAL PURPOSE REGISTER
-//~~~~~~~~~~~~~~~~~~~~~~~~~~
-#define M_CPU_LOG2_NB_GPR_LOG 5
-#define M_CPU_NB_GPR_LOG      (1<<M_CPU_LOG2_NB_GPR_LOG)
-#define GPR_LOG_LR            0x09          // Link register
-#define REG_PHY_SR            0x00          // Status register
-//~~~~~~~~~~~~~~~~~~~~~~~~~~
-// SPECIAL PURPOSE REGISTER
-//~~~~~~~~~~~~~~~~~~~~~~~~~~
-#define M_CPU_LOG2_NB_SPR_LOG 1
-#define M_CPU_NB_SPR_LOG      (1<<M_CPU_LOG2_NB_SPR_LOG)
-#define M_CPU_SPR_SIZE_DATA   2             // Size of the most great register
-#define SPR_LOG_SR_F          0x00          // Status register bit F                   (size = 1)
-#define SPR_LOG_SR_CY_OV      0x01          // Status register bit overflow and carry  (size = 2)
-//#define SPR_LOG_SR_LO         0x02          // MAC LSB                                 (size = 32)
-//#define SPR_LOG_SR_HI         0x03          // MAC MSB                                 (size = 32)
-  */
-  /*
-  */
 }; // end namespace behavioural
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Debug_component.h

-              r86
+              r88
 #define Debug_component_H
+#  define DEBUG_true                                                true
+#  define DEBUG_false                                               false
+// Boolean
+#  define DEBUG_true                                              true
+#  define DEBUG_false                                             false
+#  define DEBUG_Behavioural                                         false
+#  define   DEBUG_Generic                                           false
+#  define     DEBUG_Counter                                         false
+#  define     DEBUG_Queue                                           false
+#  define     DEBUG_Queue_Control                                   false
+#  define     DEBUG_RegisterFile                                    false
+#  define       DEBUG_RegisterFile_Monolithic                       false
+#  define       DEBUG_RegisterFile_Multi_Banked                     false
+#  define     DEBUG_Select                                          false
+#  define       DEBUG_Select_Priority_Fixed                         false
+#  define     DEBUG_Shifter                                         false
+#  define     DEBUG_Sort                                            false
+#  define     DEBUG_Victim                                          false
+#  define       DEBUG_Victim_Pseudo_LRU                             false
+#  define   DEBUG_Core                                              false
+#  define     DEBUG_Multi_Execute_loop                              false
+#  define       DEBUG_Execute_loop                                  false
+#  define         DEBUG_Multi_Execute_unit                          false
+#  define           DEBUG_Execute_unit                              false
+#  define             DEBUG_Functionnal_unit                        false
+#  define             DEBUG_Load_store_unit                         false
+#  define         DEBUG_Multi_Read_unit                             false
+#  define           DEBUG_Read_unit                                 false
+#  define             DEBUG_Read_queue                              false
+#  define             DEBUG_Reservation_station                     false
+#  define         DEBUG_Multi_Write_unit                            false
+#  define           DEBUG_Write_unit                                false
+#  define             DEBUG_Execute_queue                           false
+#  define             DEBUG_Write_queue                             false
+#  define         DEBUG_Network                                     false
+#  define           DEBUG_Execution_unit_to_Write_unit              false
+#  define           DEBUG_Read_unit_to_Execution_unit               false
+#  define         DEBUG_Register_unit                               false
+#  define           DEBUG_Register_unit_Glue                        false
+#  define     DEBUG_Multi_Front_end                                 false
+#  define       DEBUG_Front_end                                     false
+#  define         DEBUG_Context_State                               false
+#  define         DEBUG_Decod_unit                                  true
+#  define           DEBUG_Decod                                     true
+#  define           DEBUG_Decod_queue                               true
+#  define         DEBUG_Ifetch_unit                                 false
+#  define           DEBUG_Address_management                        false
+#  define           DEBUG_Ifetch_queue                              false
+#  define           DEBUG_Ifetch_unit_Glue                          false
+#  define         DEBUG_Prediction_unit                             false
+#  define           DEBUG_Branch_Target_Buffer                      false
+#  define             DEBUG_Branch_Target_Buffer_Glue               false
+#  define             DEBUG_Branch_Target_Buffer_Register           false
+#  define           DEBUG_Direction                                 false
+#  define             DEBUG_Direction_Glue                          false
+#  define             DEBUG_Meta_Predictor                          false
+#  define               DEBUG_Meta_Predictor_Glue                   false
+#  define               DEBUG_Two_Level_Branch_Predictor            false
+#  define                 DEBUG_Two_Level_Branch_Predictor_Glue     false
+#  define                 DEBUG_Branch_History_Table                false
+#  define                 DEBUG_Pattern_History_Table               false
+#  define           DEBUG_Prediction_unit_Glue                      false
+#  define           DEBUG_Return_Address_Stack                      false
+#  define           DEBUG_Update_Prediction_Table                   false
+#  define     DEBUG_Multi_OOO_Engine                                false
+#  define       DEBUG_OOO_Engine                                    false
+#  define         DEBUG_Rename_unit                                 false
+#  define           DEBUG_Load_Store_pointer_unit                   false
+#  define           DEBUG_Register_translation_unit                 false
+#  define             DEBUG_Dependency_checking_unit                false
+#  define             DEBUG_Free_List_unit                          false
+#  define             DEBUG_Register_Address_Translation_unit       false
+#  define             DEBUG_Register_translation_unit_Glue          false
+#  define             DEBUG_Stat_List_unit                          false
+//#define           DEBUG_Rename_queue                              false
+#  define           DEBUG_Rename_select                             false
+// Component
+#  define DEBUG_Morpheo                                           true
+#  define   DEBUG_Behavioural                                     true
+#  define   DEBUG_Configuration                                   true
+#  define     DEBUG_Generic                                       true
+#  define       DEBUG_Counter                                     true
+#  define       DEBUG_Priority                                    true
+#  define       DEBUG_Queue                                       true
+#  define       DEBUG_Queue_Control                               true
+#  define       DEBUG_RegisterFile                                true
+#  define         DEBUG_RegisterFile_Monolithic                   true
+#  define         DEBUG_RegisterFile_Multi_Banked                 true
+#  define       DEBUG_Select                                      true
+#  define         DEBUG_Select_Priority_Fixed                     true
+#  define       DEBUG_Shifter                                     true
+#  define       DEBUG_Sort                                        true
+#  define       DEBUG_Victim                                      true
+#  define         DEBUG_Victim_Pseudo_LRU                         true
+#  define     DEBUG_Core                                          true
+#  define       DEBUG_Core_Glue                                   true
+#  define       DEBUG_Dcache_Access                               true
+#  define       DEBUG_Icache_Access                               true
+#  define       DEBUG_Multi_Front_end                             true
+#  define         DEBUG_Front_end                                 true
+#  define           DEBUG_Context_State                           true
+#  define           DEBUG_Decod_unit                              true
+#  define             DEBUG_Decod                                 true
+#  define             DEBUG_Decod_queue                           true
+#  define           DEBUG_Front_end_Glue                          true
+#  define           DEBUG_Ifetch_unit                             true
+#  define             DEBUG_Address_management                    true
+#  define             DEBUG_Ifetch_queue                          true
+#  define             DEBUG_Ifetch_unit_Glue                      true
+#  define           DEBUG_Prediction_unit                         true
+#  define             DEBUG_Branch_Target_Buffer                  true
+#  define               DEBUG_Branch_Target_Buffer_Glue           true
+#  define               DEBUG_Branch_Target_Buffer_Register       true
+#  define             DEBUG_Direction                             true
+#  define               DEBUG_Direction_Glue                      true
+#  define               DEBUG_Meta_Predictor                      true
+#  define                 DEBUG_Meta_Predictor_Glue               true
+#  define                 DEBUG_Two_Level_Branch_Predictor        true
+#  define                   DEBUG_Two_Level_Branch_Predictor_Glue true
+#  define                   DEBUG_Branch_History_Table            true
+#  define                   DEBUG_Pattern_History_Table           true
+#  define             DEBUG_Prediction_unit_Glue                  true
+#  define             DEBUG_Return_Address_Stack                  true
+#  define             DEBUG_Update_Prediction_Table               true
+#  define       DEBUG_Multi_OOO_Engine                            true
+#  define         DEBUG_OOO_Engine                                true
+#  define           DEBUG_Commit_unit                             true
+#  define           DEBUG_Issue_queue                             true
+#  define           DEBUG_OOO_Engine_Glue                         true
+#  define           DEBUG_Reexecute_unit                          true
+#  define           DEBUG_Rename_unit                             true
+#  define             DEBUG_Load_Store_pointer_unit               true
+#  define             DEBUG_Register_translation_unit             true
+#  define               DEBUG_Dependency_checking_unit            true
+#  define               DEBUG_Free_List_unit                      true
+#  define               DEBUG_Register_Address_Translation_unit   true
+#  define               DEBUG_Register_translation_unit_Glue      true
+#  define               DEBUG_Stat_List_unit                      true
+#  define             DEBUG_Rename_select                         true
+#  define             DEBUG_Rename_unit_Glue                      true
+#  define           DEBUG_Special_Register_unit                   true
+#  define       DEBUG_Multi_Execute_loop                          true
+#  define         DEBUG_Execute_loop                              true
+#  define           DEBUG_Execute_loop_Glue                       true
+#  define           DEBUG_Multi_Execute_unit                      true
+#  define             DEBUG_Execute_unit                          true
+#  define               DEBUG_Functionnal_unit                    true
+#  define               DEBUG_Load_store_unit                     true
+#  define           DEBUG_Multi_Read_unit                         true
+#  define             DEBUG_Read_unit                             true
+#  define               DEBUG_Read_queue                          true
+#  define               DEBUG_Reservation_station                 true
+#  define           DEBUG_Multi_Write_unit                        true
+#  define             DEBUG_Write_unit                            true
+#  define               DEBUG_Execute_queue                       true
+#  define               DEBUG_Write_queue                         true
+#  define           DEBUG_Network                                 true
+#  define             DEBUG_Execution_unit_to_Write_unit          true
+#  define             DEBUG_Read_unit_to_Execution_unit           true
+#  define           DEBUG_Register_unit                           true
+#  define             DEBUG_Register_unit_Glue                    true
+// Others
+#  define DEBUG_Allocation                                        true
+#  define DEBUG_Interface                                         true
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Environment.h

-              r81
+              r88
 #define morpheo_behavioural_Environment_h
+#if (defined(STATISTICS) and not defined(SYSTEMC))
+#  error "To have the statistics, you must set flags SYSTEMC"
+#endif
+#if (defined(INFORMATION) and not defined(STATISTICS))
+#  error "To have the information, you must set flags STATISTICS"
+#endif
+#if (defined(VHDL_TESTBENCH) and not defined(SYSTEMC))
+#  error "To have the vhdl's test bench, you must set flags SYSTEMC"
+#endif
+#if (defined(VHDL_TESTBENCH) and not defined(VHDL))
+#  error "To have the vhdl's test bench, you must set flags VHDL"
+#endif
+#if (defined(VHDL_TESTBENCH_ASSERT) and not defined(VHDL_TESTBENCH))
+#  error "To have an assert in vhdl's test bench, you must set flags VHDL_TESTBENCH"
+#endif
+#if (defined(VHDL_TESTBENCH) and defined(SYSTEMC))
+#  define SYSTEMC_VHDL_COMPATIBILITY
+#endif
+#if (defined(DEBUG))
+#  define DEBUG_TEST
+#endif
+// Environment variable
+#define MORPHEO_HOME          "MORPHEO_HOME"
+//#include "Common/include/Environment.h"
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Interface.h

-              r82
+              r88
+  {
     // -----[ fields ]----------------------------------------------------
   protected : const std::string          _name         ;
+  protected : const std::string     _name         ;
 #ifdef POSITION
   protected : const direction_t     _direction    ;
 …
 #ifdef POSITION
   protected :       std::string          _comment      ;
 #endif
   protected : std::list<Signal *>      * _list_signal  ;
+  protected :       std::string     _comment      ;
+#endif
+  protected : std::list<Signal *> * _list_signal  ;
 #ifdef POSITION
 …
   public    :                       ~Interface           ();
   public    : std::string                get_name             ();
+  public    : std::string           get_name             ();
 #ifdef POSITION
   public    : void                  set_comment          (std::string comment);
   protected : std::string                get_comment          (void          );
 #endif
   protected : std::string                signal_name          (std::string      name_interface,
                                                           std::string      name_signal   ,
+  protected : std::string           get_comment          (void);
+#endif
+  protected : std::string           signal_name          (std::string name_interface,
+                                                          std::string name_signal   ,
                                                           direction_t direction     );
 …
   public    : bool                  find_signal          (Signal * signal);
   protected : std::string                get_signal           (void);
   public    : Signal *              set_signal           (std::string          name     ,
+  protected : std::string           get_signal           (void);
+  public    : Signal *              set_signal           (std::string     name     ,
                                                           direction_t     direction,
                                                           uint32_t        size     ,
                                                           presence_port_t presence_port = PORT_VHDL_YES_TESTBENCH_YES);
   public    : std::list<Signal *>      * get_signal_list      (void);
+  public    : std::list<Signal *> * get_signal_list      (void);
 #ifdef SYSTEMC
   public    : sc_in_clk *           set_signal_clk       (std::string          name     ,
+  public    : sc_in_clk *           set_signal_clk       (std::string     name     ,
                                                           uint32_t        size     ,
                                                           presence_port_t presence_port=CLOCK_VHDL_YES)
 …
   public    : template <typename T>
               sc_in <T> *           set_signal_in       (std::string          name     ,
+              sc_in <T> *           set_signal_in       (std::string     name     ,
                                                          uint32_t        size     ,
                                                          presence_port_t presence_port=PORT_VHDL_YES_TESTBENCH_YES)
 …
   public    : template <typename T>
               sc_out <T> *          set_signal_out      (std::string          name     ,
+              sc_out <T> *          set_signal_out      (std::string     name     ,
                                                          uint32_t        size     ,
                                                          presence_port_t presence_port=PORT_VHDL_YES_TESTBENCH_YES)
 …
   public    : void                  testbench_cycle      (void);
   public    : void                  testbench_body       (Vhdl           * & vhdl          ,
                                                           std::string             counter_name  ,
                                                           std::string             reset_name    );
+                                                          std::string        counter_name  ,
+                                                          std::string        reset_name    );
   public    : std::string           testbench_test       (Vhdl           * & vhdl        ,
                                                           std::string             counter_name,
                                                           std::string             reset_name);
   public    : std::string           testbench_test_ok    (Vhdl           * & vhdl        );
   protected : std::string           testbench_test_name   (Vhdl           * & vhdl);
   protected : std::string           testbench_test_ok_name(Vhdl           * & vhdl);
   protected : std::string           testbench_test_transaction_name(Vhdl           * & vhdl);
+                                                          std::string        counter_name,
+                                                          std::string        reset_name);
+  public    : std::string           testbench_test_ok               (Vhdl * & vhdl);
+  protected : std::string           testbench_test_name             (Vhdl * & vhdl);
+  protected : std::string           testbench_test_ok_name          (Vhdl * & vhdl);
+  protected : std::string           testbench_test_transaction_name (Vhdl * & vhdl);
 #endif
   public    : bool                  test_map             (uint32_t depth, bool top_level, bool is_behavioural);
 //   public    : bool                  test_equi            (uint32_t depth);
+//public    : bool                  test_equi            (uint32_t depth);
 #ifdef POSITION
 …
   public    : XML                   toXML_mapping        (void);
 #endif
   public    : friend std::ostream&       operator<<           (std::ostream& output_stream,
                                                                morpheo::behavioural::Interface & x);
+  public    : friend std::ostream&  operator<<           (std::ostream& output_stream,
+                                                          morpheo::behavioural::Interface & x);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Interface_fifo.h

-              r82
+              r88
  * $Id$
+ *
  * [ Description ]
+ * [ Description ]
+ *
  */
 …
 #ifdef VHDL_TESTBENCH
   private   : bool                  _test_exhaustive;
+  private   : bool                       _test_exhaustive;
   private   : std::list<uint32_t>      * _list_cycle   ;
 #endif
    // -----[ methods ]---------------------------------------------------
+   // -----[ methods ]---------------------------------------------------
   public    :                       Interface_fifo       (std::string         name
 #ifdef POSITION
 …
   public    : bool                  testbench_transaction(void);
   public    : void                  testbench_cycle      (void);
+  public    : std::string           testbench_test       (Vhdl   * & vhdl        ,
+                                                          std::string     counter_name,
+                                                          std::string     reset_name  );
+  public    : std::string           testbench_test       (Vhdl    * & vhdl        ,
+                                                          std::string counter_name,
+                                                          std::string reset_name  );
+#ifdef VHDL_TESTBENCH_ASSERT
+  public    : void                  testbench_assert     (Vhdl    * & vhdl        ,
+                                                          std::string counter_name);
+#endif
   public    : std::string           testbench_test_transaction (Vhdl * & vhdl);

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Interfaces.h

-              r82
+              r88
+  {
     // -----[ fields ]----------------------------------------------------
   private   : const std::string               _name;
   private   : const Tusage_t             _usage;
   private   : std::list<Interface_fifo*>    * _list_interface;
+  private   : const std::string            _name;
+  private   : const Tusage_t               _usage;
+  private   : std::list<Interface_fifo*> * _list_interface;
     // -----[ methods ]---------------------------------------------------

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Parameters.h

-              r82
+              r88
  */
+#include <stdint.h>
+#include <iostream>
+#include <math.h>
+#include "Behavioural/include/Environment.h"
+#include "Common/include/Environment.h"
+#include "Behavioural/include/Parameters_test.h"
 #include "Behavioural/include/Constants.h"
 #include "Behavioural/include/Test.h"
 …
 #include "Common/include/Log2.h"
 #include "Common/include/Debug.h"
+#include <stdint.h>
+#include <iostream>
+#include <math.h>
 namespace morpheo     {
 namespace behavioural {
+#ifdef COPY
+#error "Need COPY macro"
+#endif
+  template <typename T> bool test (uint32_t size)
+  {
+    return (size <= (8*sizeof(T)));
+  };
+  class Parameters_test
+  {
+  private   : std::string _component;
+  protected : std::string _error;
+  protected : std::string _warning;
+  protected : std::string _information;
+  public    : Parameters_test (std::string component)
+    {
+      _component = component;
+      _error     = "";
+      _warning   = "";
+    };
+  public    : ~Parameters_test (void) {};
+  public    : bool        have_error  (void)            { return (_error.length() != 0);};
+  public    : void        error       (std::string str) { _error       += MSG_ERROR      ; _error       += " <" + _component + "> " + str + "\n";}
+  public    : void        warning     (std::string str) { _warning     += MSG_WARNING    ; _warning     += " <" + _component + "> " + str + "\n";}
+  public    : void        information (std::string str) { _information += MSG_INFORMATION; _information += " <" + _component + "> " + str + "\n";}
+  public    : std::string print       (void)            { return _error + _warning + _information;};
+  };
+#define COPY(param) do {duplicate(param); param->copy();} while (0)
   // Virtual Class - Interface of each component
 …
+  {
     // -----[ fields ]----------------------------------------------------
+  public   : static const uint32_t   _size_instruction            = 32;
+  public   : static const uint32_t   _nb_operation                = MAX_OPERATION;
+  public   : static const uint32_t   _nb_type                     = MAX_TYPE;
+  public   : static const uint32_t   _size_operation              = SIZE_OPERATION;
+  public   : static const uint32_t   _size_type                   = SIZE_TYPE;
+  public   : static const uint32_t   _size_exception              = SIZE_EXCEPTION;
+  public   : static const uint32_t   _size_exception_use          = SIZE_EXCEPTION_USE;
+  public   : static const uint32_t   _size_exception_memory       = SIZE_EXCEPTION_MEMORY;
+  public   : static const uint32_t   _size_exception_custom       = SIZE_EXCEPTION_CUSTOM;
+  public   : static const uint32_t   _size_exception_alu          = SIZE_EXCEPTION_ALU   ;
+  public   : static const uint32_t   _size_exception_decod        = SIZE_EXCEPTION_DECOD ;
+  public   : static const uint32_t   _size_exception_ifetch       = SIZE_EXCEPTION_IFETCH;
+  public   : static const uint32_t   _size_icache_type            = SIZE_ICACHE_TYPE;
+  public   : static const uint32_t   _size_icache_error           = SIZE_ICACHE_ERROR;
+  public   : static const uint32_t   _size_dcache_type            = SIZE_DCACHE_TYPE;
+  public   : static const uint32_t   _size_dcache_error           = SIZE_DCACHE_ERROR;
+  public   : static const uint32_t   _nb_general_register_logic   = 32;
+  public   : static const uint32_t   _nb_special_register_logic   = NB_SPR_LOGIC;
+  public   : static const uint32_t   _size_general_register_logic = 5;
+  public   : static const uint32_t   _size_special_register_logic = LOG2_NB_SPR_LOGIC;
+  public   : static const uint32_t   _size_event_state            = SIZE_EVENT_STATE;
+  public   : static const uint32_t   _size_event_type             = SIZE_EVENT_TYPE;
+  public   : static const uint32_t   _size_branch_state           = SIZE_BRANCH_STATE;
+  public   : static const uint32_t   _size_branch_condition       = SIZE_BRANCH_CONDITION;
+  public   : static const uint32_t   _size_instruction              = 32;
+  public   : static const uint32_t   _size_spr                      = 32;
+  public   : static const uint32_t   _nb_operation                  = MAX_OPERATION;
+  public   : static const uint32_t   _nb_type                       = MAX_TYPE;
+  public   : static const uint32_t   _size_operation                = SIZE_OPERATION;
+  public   : static const uint32_t   _size_type                     = SIZE_TYPE;
+  public   : static const uint32_t   _size_exception                = SIZE_EXCEPTION;
+  public   : static const uint32_t   _size_exception_use            = SIZE_EXCEPTION_USE;
+  public   : static const uint32_t   _size_exception_memory         = SIZE_EXCEPTION_MEMORY;
+  public   : static const uint32_t   _size_exception_custom         = SIZE_EXCEPTION_CUSTOM;
+  public   : static const uint32_t   _size_exception_alu            = SIZE_EXCEPTION_ALU   ;
+  public   : static const uint32_t   _size_exception_decod          = SIZE_EXCEPTION_DECOD ;
+  public   : static const uint32_t   _size_exception_ifetch         = SIZE_EXCEPTION_IFETCH;
+  public   : static const uint32_t   _size_icache_type              = SIZE_ICACHE_TYPE;
+  public   : static const uint32_t   _size_icache_error             = SIZE_ICACHE_ERROR;
+  public   : static const uint32_t   _size_dcache_type              = SIZE_DCACHE_TYPE;
+  public   : static const uint32_t   _size_dcache_error             = SIZE_DCACHE_ERROR;
+  public   : static const uint32_t   _nb_general_register_logic     = 32;
+  public   : static const uint32_t   _nb_special_register_logic     = NB_SPR_LOGIC;
+  public   : static const uint32_t   _size_general_register_logic   = 5;
+  public   : static const uint32_t   _size_special_register_logic   = LOG2_NB_SPR_LOGIC;
+  public   : static const uint32_t   _size_special_address_group    = 5;
+  public   : static const uint32_t   _size_special_address_register = 11;
+  public   : static const uint32_t   _size_event_state              = SIZE_EVENT_STATE;
+  public   : static const uint32_t   _size_event_type               = SIZE_EVENT_TYPE;
+  public   : static const uint32_t   _size_branch_state             = SIZE_BRANCH_STATE;
+  public   : static const uint32_t   _size_branch_condition         = SIZE_BRANCH_CONDITION;
+  public   : static const uint32_t   _shift_spr_num_group           = _size_special_address_register;
+  public   : static const uint32_t   _mask_spr_num_group            = 0x1f ; //        1_1111
+  public   : static const uint32_t   _mask_spr_num_reg              = 0x7ff; // 111_1111_1111
+    // simulation
+  public  :               uint64_t   _simulation_nb_cyle                    ;
+  public  :               uint64_t   _simulation_nb_instruction             ;
+    // parameters depends
+  public   :              uint32_t   _size_context_id                       ;
+  public   :              bool       _have_port_context_id                  ;
+  public   :              uint32_t   _size_front_end_id                     ;
+  public   :              bool       _have_port_front_end_id                ;
+  public   :              uint32_t   _size_ooo_engine_id                    ;
+  public   :              bool       _have_port_ooo_engine_id               ;
+  public   :              uint32_t   _size_instruction_address              ;
+//public   :              bool       _have_port_instruction_address         ; // always true
+  public   :              uint32_t   _size_data_address                     ;
+//public   :              bool       _have_port_data_address                ; // always true
+  public   :              uint32_t   _size_nb_inst_decod                    ;
+//public   :              bool       _have_port_nb_inst_decod               ; // always true
+  public   :              uint32_t   _size_nb_inst_commit                   ;
+//public   :              bool       _have_port_nb_inst_commit              ; // always true
+  public   :              uint32_t   _size_depth                            ;
+  public   :              bool       _have_port_depth                       ;
+  public   :              uint32_t   _size_ifetch_queue_ptr                 ;
+  public   :              bool       _have_port_ifetch_queue_ptr            ;
+  public   :              uint32_t   _size_inst_ifetch_ptr                  ; // nb_inst_fetch
+  public   :              bool       _have_port_inst_ifetch_ptr             ;
+//public   :              uint32_t   _size_branch_update_prediction_id      ; // = size_depth
+//public   :              bool       _have_port_branch_update_prediction_id ; // = size_depth
+  public   :              uint32_t   _size_rob_ptr                          ;
+  public   :              bool       _have_port_rob_ptr                     ;
+  public   :              uint32_t   _size_load_queue_ptr                   ;
+  public   :              bool       _have_port_load_queue_ptr              ;
+  public   :              uint32_t   _size_store_queue_ptr                  ;
+//public   :              bool       _have_port_store_queue_ptr             ; // always true (min = 1)
+  public   :              uint32_t   _size_general_data                     ;
+//public   :              bool       _have_port_general_data                ; // always true
+  public   :              uint32_t   _size_special_data                     ;
+//public   :              bool       _have_port_special_data                ; // always true
+  public   :              uint32_t   _size_general_register                 ;
+//public   :              bool       _have_port_general_register            ; // always true
+  public   :              uint32_t   _size_special_register                 ;
+//public   :              bool       _have_port_special_register            ; // always true
     // -----[ methods ]---------------------------------------------------
 …
   public   : virtual Parameters_test    msg_error   (void) = 0;
+    // methods to generate configuration file
+    // methods to copy depends parameters
+    // (these parameters can't be static : because can have multi instance of toplevel)
+  public   : virtual void               copy        (void) = 0;
+//public   :         void               copy        (Parameters * param);
+  public   :         void               duplicate   (Parameters * param);
     // methods to test
   public   :         void               test        (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/SPR_access_mode.h

-              r81
+              r88
 namespace behavioural {
   typedef struct
+  class spr_address_t
+  {
+    Tgeneral_data_t _group;
+    Tgeneral_data_t _register;
+  } spr_address_t;
+  public : Tgeneral_data_t _group;
+  public : Tgeneral_data_t _register;
+  public : spr_address_t (void) {};
+  public : spr_address_t (Tgeneral_data_t grp,
+                          Tgeneral_data_t reg)
+    {
+      _group    = grp;
+      _register = reg;
+    };
+  };
   class SPR_access_mode
+  {
   private : spr_access_mode_t   ** _spr_generic;
   private : uint32_t             * _max_register_by_group;
+  private : spr_access_mode_t   ** _spr_generic          ; //[NB_GROUP][NB_REG_GROUP]
+  private : uint32_t             * _max_register_by_group; //[NB_GROUP]
   public  : SPR_access_mode();
 …
   public  : bool          valid (uint32_t num_group, uint32_t num_reg);
   public  : bool          valid (spr_address_t address);
+  public  : bool          exist (uint32_t num_group, uint32_t num_reg);
+  public  : bool          exist (spr_address_t address);
   public  : bool          read  (spr_address_t address, Tcontrol_t SM, Tcontrol_t SUMRA);
   public  : bool          write (spr_address_t address, Tcontrol_t SM, Tcontrol_t SUMRA);
 …
   public  : uint32_t      implement_group (uint32_t num_group);
   public  : void          change_mode     (uint32_t num_group, uint32_t num_reg, spr_access_mode_t new_mode);
+  public  : void          invalid_register(uint32_t num_group, uint32_t num_reg);
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Signal.h

-              r82
+              r88
                 UINT64_T                   } type_info_t;
+  typedef enum {PORT_VHDL_YES_TESTBENCH_YES,
+  typedef enum {PORT_SYSTEMC_NO            , // also, vhdl_no and testbench_no
+                PORT_VHDL_YES_TESTBENCH_YES,
                 PORT_VHDL_YES_TESTBENCH_NO ,
                 PORT_VHDL_NO_TESTBENCH_YES ,
 …
     // -----[ methods ]---------------------------------------------------
   public    :                   Signal          (std::string          name          ,
                                                  direction_t     direction     ,
                                                  uint32_t        size          ,
                                                  presence_port_t presence_port = PORT_VHDL_YES_TESTBENCH_YES);
   public    :                   Signal          (const Signal &);
   public    :                   ~Signal         ();
+  public    :                   Signal                  (std::string     name          ,
+                                                         direction_t     direction     ,
+                                                         uint32_t        size          ,
+                                                         presence_port_t presence_port = PORT_VHDL_YES_TESTBENCH_YES);
+  public    :                   Signal                  (const Signal &);
+  public    :                   ~Signal                 ();
   public    : std::string       get_name                (void);
 …
   public    : bool              test_map                (uint32_t depth, bool top_level, bool is_behavioural);
 //   public    : bool              test_equi               (uint32_t depth);
+//public    : bool              test_equi               (uint32_t depth);
   public    : void              link                    (Signal * signal_dest,
 …
         case IN  : {return read_in  <T>();}
         case OUT : {return read_out <T>();}
         default  : throw (ErrorMorpheo ("Signal \""+_name+"\" : direction unknow."));
+        default  : throw (ErrorMorpheo ("Signal \""+_name+"\" : direction unknow.\n"));
+        }
+    }
 …
         case UINT32_T : return (static_cast<sc_in  <uint32_t> *>(_sc_signal_map)->read());
         case UINT64_T : return (static_cast<sc_in  <uint64_t> *>(_sc_signal_map)->read());
         default       : throw (ErrorMorpheo ("Signal \""+_name+"\" : type unknow."));
+        default       : throw (ErrorMorpheo ("Signal \""+_name+"\" : type unknow.\n"));
+        }
+    }
 …
         case UINT32_T : return (static_cast<sc_out <uint32_t> *>(_sc_signal_map)->read());
         case UINT64_T : return (static_cast<sc_out <uint64_t> *>(_sc_signal_map)->read());
         default       : throw (ErrorMorpheo ("Signal \""+_name+"\" : type unknow."));
+        default       : throw (ErrorMorpheo ("Signal \""+_name+"\" : type unknow.\n"));
+        }
+    }
 …
       if (_type_info != UNKNOW)
         throw (ErrorMorpheo ("Signal \""+_name+"\" : already allocate."));
+        throw (ErrorMorpheo (toString(_("Signal \"%s\" : already allocate.\n"),_name.c_str())));
       if (test<T>(_size) == false)
         throw (ErrorMorpheo ("Signal \""+_name+"\" : size is too small to the associate type."));
+        throw (ErrorMorpheo (toString(_("Signal \"%s\" : size is too small (%d bits) to the associate type (%d bits).\n"),_name.c_str(),_size,8*sizeof(T))));
       _is_allocate    = true;
 …
       _sc_signal_map  = sc_signal;
-      log_printf(TRACE,Behavioural,FUNCTION, "Allocation of %s - %.8x", _name.c_str(), (uint32_t)(_sc_signal_map));
       if (typeid(T) == typeid(bool    ))
         _type_info = BOOL;
 …
       else
         _type_info = UNKNOW;
+      log_printf(TRACE,Behavioural,FUNCTION, "Allocation of %s (%s, 0x%.8x)", _name.c_str(),toString(_type_info).c_str(), static_cast<uint32_t>(reinterpret_cast<uint64_t>(_sc_signal_map)));
       log_printf(FUNC,Behavioural,FUNCTION,"End");
 …
   };
 }; // end namespace behavioural
   template<>           inline std::string toString<morpheo::behavioural::presence_port_t>(const morpheo::behavioural::presence_port_t& x)
 …
+  }
+  typedef enum {UNKNOW                     ,
+                BOOL                       ,
+                UINT8_T                    ,
+                UINT16_T                   ,
+                UINT32_T                   ,
+                UINT64_T                   } type_info_t;
+  template<>           inline std::string toString<morpheo::behavioural::type_info_t>(const morpheo::behavioural::type_info_t& x)
+  {
+    switch (x)
+      {
+      case morpheo::behavioural::BOOL     : return "bool"    ; break;
+      case morpheo::behavioural::UINT8_T  : return "uint8_t" ; break;
+      case morpheo::behavioural::UINT16_T : return "uint16_t"; break;
+      case morpheo::behavioural::UINT32_T : return "uint32_t"; break;
+      case morpheo::behavioural::UINT64_T : return "uint64_t"; break;
+      case morpheo::behavioural::UNKNOW   :
+      default                             : return "unknow"  ; break;
+      }
+  }
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Stat.h

-              r84
+              r88
     class Stat
+    {
       const std::string              _name_instance;
       const std::string              _name_component;
       const cycle_t                  _nb_cycle_before_begin;
       const cycle_t                  _period;
       const bool                     _save_periodic;
+    private: const std::string              _name_instance;
+    private: const std::string              _name_component;
+    private: const cycle_t                  _nb_cycle_before_begin;
+    private: const cycle_t                  _period;
+    private: const bool                     _save_periodic;
       // Tableau des variables
       std::map<std::string, var_t> * _list_operand;
+    private: std::map<std::string, var_t> * _list_operand;
       // Liste chaîné des expressions
       std::list<expr_t>            * _list_expr;
+    private: std::list<expr_t>            * _list_expr;
       counter_t                    * _cycle;
+    private: counter_t                    * _cycle;
       std::list<Stat *>            * _list_stat;
+    private: std::list<Stat *>            * _list_stat;
       bool                           _generate_file;
+    private: bool                           _generate_file;
     public :                     Stat                         (std::string name_instance,

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Stat_binary_tree.h

-              r81
+              r88
 namespace behavioural {
   typedef enum {VARIABLE, CONSTANT, OPERATOR_UNARY, OPERATOR_BINARY} data_type_t;
+  typedef enum {NONE, VARIABLE, CONSTANT, OPERATOR_UNARY, OPERATOR_BINARY} data_type_t;
   typedef union
 …
+  {
     // arbre binaire
     private : Stat_binary_tree * _root;
     private : Stat_binary_tree * _left;
     private : Stat_binary_tree * _right;
     private : data_type_t        _data_type;
     private : data_t             _data;
+  private : Stat_binary_tree * _root;
+  private : Stat_binary_tree * _left;
+  private : Stat_binary_tree * _right;
+  private : data_type_t        _data_type;
+  private : data_t             _data;
     /*     private :  Stat_binary_tree (data_type_t data_type, data_t data); */
     public  :  Stat_binary_tree (counter_t   cst);
     public  :  Stat_binary_tree (counter_t * var);
     public  :  Stat_binary_tree (operator_t  op );
     public  : ~Stat_binary_tree (void);
+  public  :  Stat_binary_tree (std::string expr,
+                               std::map<std::string, counter_t*> * operand);
+  public  :  Stat_binary_tree (counter_t   cst);
+  public  :  Stat_binary_tree (counter_t * var);
+  public  :  Stat_binary_tree (operator_t  op );
+    private : void               insert_tree (Stat_binary_tree * tree);
+    public  : Stat_binary_tree * insert_tree (counter_t   cst);
+    public  : Stat_binary_tree * insert_tree (counter_t * var);
+    public  : Stat_binary_tree * insert_tree (operator_t  op );
+  public  : ~Stat_binary_tree (void);
+  private : void               insert_tree (Stat_binary_tree * tree);
+  public  : Stat_binary_tree * insert_tree (counter_t   cst);
+  public  : Stat_binary_tree * insert_tree (counter_t * var);
+  public  : Stat_binary_tree * insert_tree (operator_t  op );
+    public  : Stat_binary_tree * goto_top_level (void);
+    public  : Stat_binary_tree * goto_next_root (void);
+  private : void               change_type (counter_t   cst);
+  private : void               change_type (counter_t * var);
+  private : void               change_type (operator_t  op );
+  public  : Stat_binary_tree * goto_top_level (void);
+  public  : Stat_binary_tree * goto_next_root (void);
     public  : bool      valid    (void);
+  public  : bool               valid    (void);
     public  : counter_t eval     (void);
+  public  : counter_t          eval     (void);
+    private : counter_t val_tree (void);
+    private : counter_t val_leaf (void);
+    private : bool      is_leaf  (void);
+  private : counter_t          val_tree (void);
+  private : counter_t          val_leaf (void);
+  private : bool               is_leaf  (void);
+  public  : void               import   (std::string expr,
+                                         std::map<std::string, counter_t*> * operand);
+  public  : void               print    (uint32_t depth=0);
 //     public  : friend std::ostream& operator<< (std::ostream&, const morpheo::Stat_binary_tree &);

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Types.h

-              r81
+              r88
   typedef uint8_t            Tcounter_t; // universal counter
   typedef uint8_t            Tptr_t;     // universal pointer
+  typedef uint32_t           Tspr_t;
+  typedef uint16_t           Tspr_address_t;
 //typedef uint32_t           Tdestination1_t;
 //typedef uint32_t           Tdestination2_t;
 …
   typedef enum
+    {
+      ORBIS32,
+      ORBIS64,
+      ORFPX32,
+      ORFPX64,
+      ORVDX64
+    } ISA;
+  typedef enum
+    {
       PRIORITY_STATIC,
       PRIORITY_ROUND_ROBIN
 …
       PREDICTOR_NEVER_TAKE      , // Branch is never  Take
       PREDICTOR_ALWAYS_TAKE     , // Branch is always Take
       PREDICTOR_STATIC          , // If the adress of destination is previous, then the branch is take
+      PREDICTOR_STATIC          , // If the address of destination is previous, then the branch is take
       PREDICTOR_LAST_TAKE       , // The direction is as the last time (if is the first time : static)
       PREDICTOR_COUNTER         , // Counter table
 …
       PREDICTOR_GLOBAL          , // Counter bank indexed with history table
       PREDICTOR_META            , // A meta_predictor choose between 2 predictor : the local or the global
       PREDICTOR_CUSTOM            // Note predefined scheme
+      PREDICTOR_CUSTOM            // Not predefined scheme
     } Tpredictor_t;
+  //--------------------------------------------------[ instruction ]-----
+  class instruction_t
+  {
+  public :
+    Ttype_t      _type      ;
+    Toperation_t _operation ;
+    ISA          _isa_subset;
+    uint8_t      _isa_class ;
+    instruction_t (Ttype_t      type      ,
+                   Toperation_t operation ,
+                   ISA          isa_subset,
+                   uint8_t      isa_class )
+    {
+      _type       = type      ;
+      _operation  = operation ;
+      _isa_subset = isa_subset;
+      _isa_class  = isa_class ;
+    }
+  };
+  instruction_t instruction_information (uint32_t instruction);
+  uint32_t      instruction_size_data   (uint32_t instruction);
   //----------------------------------------------[ spr_mode_access ]-----
 …
     switch (x)
+      {
+      case TYPE_ALU     : return "ALU"    ; break;
+      case TYPE_SHIFT   : return "SHIFT"  ; break;
+      case TYPE_MOVE    : return "MOVE"   ; break;
+      case TYPE_TEST    : return "TEST"   ; break;
+      case TYPE_MUL_DIV : return "MUL_DIV"; break;
+      case TYPE_EXTEND  : return "EXTEND" ; break;
+      case TYPE_FIND    : return "FIND"   ; break;
+      case TYPE_SPECIAL : return "SPECIAL"; break;
+      case TYPE_CUSTOM  : return "CUSTOM" ; break;
+      case TYPE_BRANCH  : return "BRANCH" ; break;
+      case TYPE_MEMORY  : return "MEMORY" ; break;
+      default           : return ""       ; break;
+      case TYPE_ALU     : return "ALU"        ; break;
+      case TYPE_SHIFT   : return "SHIFT"      ; break;
+      case TYPE_MOVE    : return "MOVE"       ; break;
+      case TYPE_TEST    : return "TEST"       ; break;
+      case TYPE_MUL     : return "MUL"        ; break;
+      case TYPE_DIV     : return "DIV"        ; break;
+      case TYPE_EXTEND  : return "EXTEND"     ; break;
+      case TYPE_FIND    : return "FIND"       ; break;
+      case TYPE_SPECIAL : return "SPECIAL"    ; break;
+      case TYPE_CUSTOM  : return "CUSTOM"     ; break;
+      case TYPE_BRANCH  : return "BRANCH"     ; break;
+      case TYPE_MEMORY  : return "MEMORY"     ; break;
+      default           : return "Unknow type"; break;
+      }
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Usage.h

r81	r88
16	16	# define USE_STATISTICS 0x20
17	17	# define USE_INFORMATION 0x40
	18	# define USE_HEADER 0x80
18	19	//#define USE_ 0x80
19	20

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Version.h

-              r87
+              r88
 #define MORPHEO_MAJOR_VERSION 0
 #define MORPHEO_MINOR_VERSION 2
+#define MORPHEO_REVISION      87
+#define MORPHEO_REVISION      @REVISION
+#define MORPHEO_CODENAME      "Castor"
+#define MORPHEO_DATE_DAY      @DATE_DAY
+#define MORPHEO_DATE_MONTH    @DATE_MONTH
+#define MORPHEO_DATE_YEAR     @DATE_YEAR
 #define MORPHEO_VERSION       morpheo::toString(MORPHEO_MAJOR_VERSION)+"."+morpheo::toString(MORPHEO_MINOR_VERSION)+"."+morpheo::toString(MORPHEO_REVISION)
+#define MORPHEO_HEADER        morpheo::toString(MORPHEO_VERSION)+" - "+morpheo::toString(MORPHEO_CODENAME)
+#define MORPHEO_DATE          morpheo::toString(MORPHEO_DATE_YEAR)+"/"+morpheo::toString(MORPHEO_DATE_MONTH)+"/"+morpheo::toString(MORPHEO_DATE_DAY)
 /*
  [ Change Log ]
+ |
 …
    | SystemC Only
+   |
    +-[ Minor Version 1 ]
+   +-[ Minor Version 1 ] - Castor
    | |
    | | Second Architecture, change the load_store_unit and implement exception

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Version.h.sed

-              r85
+              r88
 #define MORPHEO_MINOR_VERSION 2
 #define MORPHEO_REVISION      @REVISION
+#define MORPHEO_CODENAME      "Castor"
+#define MORPHEO_DATE_DAY      @DATE_DAY
+#define MORPHEO_DATE_MONTH    @DATE_MONTH
+#define MORPHEO_DATE_YEAR     @DATE_YEAR
 #define MORPHEO_VERSION       morpheo::toString(MORPHEO_MAJOR_VERSION)+"."+morpheo::toString(MORPHEO_MINOR_VERSION)+"."+morpheo::toString(MORPHEO_REVISION)
+#define MORPHEO_HEADER        morpheo::toString(MORPHEO_VERSION)+" - "+morpheo::toString(MORPHEO_CODENAME)
+#define MORPHEO_DATE          morpheo::toString(MORPHEO_DATE_YEAR)+"/"+morpheo::toString(MORPHEO_DATE_MONTH)+"/"+morpheo::toString(MORPHEO_DATE_DAY)
 /*
  [ Change Log ]
+ |
 …
    | SystemC Only
+   |
    +-[ Minor Version 1 ]
+   +-[ Minor Version 1 ] - Castor
    | |
    | | Second Architecture, change the load_store_unit and implement exception

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/Vhdl.h

-              r81
+              r88
 #include <iostream>
 #include <list>
 #include "Behavioural/include/Environment.h"
+#include "Common/include/Environment.h"
 #include "Behavioural/include/Direction.h"
 #include "Common/include/ToString.h"
 …
     private   : void             generate_file_package       (void);
     private   : void             generate_file_model         (void);
     private   : std::string           get_package                 (uint32_t    depth                 ,
                                                                    std::string      filename              ,
                                                                    std::string      package_name          ,
                                                                    std::string      entity_name           );
     private   : std::string           get_model                   (uint32_t    depth                 ,
                                                                    std::string      filename              ,
                                                                    std::string      entity_name           ,
                                                                    std::string      architecture_name     );
     private   : std::string           get_header                  (uint32_t    depth                 ,
                                                                    std::string      filename              );
     private   : std::string           get_entity                  (uint32_t    depth                 ,
                                                                    std::string      name                  );
     private   : std::string           get_architecture            (uint32_t    depth                 ,
                                                                    std::string      name                  ,
                                                                    std::string      entity_name           );
     private   : std::string           get_component               (uint32_t    depth                 ,
                                                                    std::string      name                  );
     private   : std::string           get_port                    (uint32_t    depth                 );
     public    : void             set_port                    (std::string      name                  ,
+    private   : std::string      get_package                 (uint32_t    depth                 ,
+                                                              std::string filename              ,
+                                                              std::string package_name          ,
+                                                              std::string entity_name           );
+    private   : std::string      get_model                   (uint32_t    depth                 ,
+                                                              std::string filename              ,
+                                                              std::string entity_name           ,
+                                                              std::string architecture_name     );
+    private   : std::string      get_header                  (uint32_t    depth                 ,
+                                                              std::string filename              );
+    private   : std::string      get_entity                  (uint32_t    depth                 ,
+                                                              std::string name                  );
+    private   : std::string      get_architecture            (uint32_t    depth                 ,
+                                                              std::string name                  ,
+                                                              std::string entity_name           );
+    private   : std::string      get_component               (uint32_t    depth                 ,
+                                                              std::string name                  );
+    private   : std::string      get_port                    (uint32_t    depth                 );
+    public    : void             set_port                    (std::string name                  ,
                                                               direction_t direction             ,
                                                               std::string      type                  );
     public    : void             set_port                    (std::string      name                  ,
+                                                              std::string type                  );
+    public    : void             set_port                    (std::string name                  ,
                                                               direction_t direction             ,
                                                               uint32_t    size                  );
     private   : std::string           get_signal                  (uint32_t    depth                 );
     public    : void             set_signal                  (std::string      name                  ,
                                                               std::string      type                  );
     public    : void             set_signal                  (std::string      name                  ,
+    private   : std::string      get_signal                  (uint32_t    depth                 );
+    public    : void             set_signal                  (std::string name                  ,
+                                                              std::string type                  );
+    public    : void             set_signal                  (std::string name                  ,
                                                               uint32_t    signal                );
     public    : void             set_signal                  (std::string      name                  ,
                                                               std::string      type                  ,
                                                               std::string      init                  );
     public    : void             set_signal                  (std::string      name                  ,
+    public    : void             set_signal                  (std::string name                  ,
+                                                              std::string type                  ,
+                                                              std::string init                  );
+    public    : void             set_signal                  (std::string name                  ,
                                                               uint32_t    size                  ,
                                                               std::string      init                  );
     public    : void             set_signal                  (std::string      name                  ,
+                                                              std::string init                  );
+    public    : void             set_signal                  (std::string name                  ,
                                                               uint32_t    size                  ,
                                                               uint32_t    init                  );
     public    : void             set_constant                (std::string      name                  ,
                                                               std::string      type                  ,
                                                               std::string      init                  );
     public    : void             set_constant                (std::string      name                  ,
+    public    : void             set_constant                (std::string name                  ,
+                                                              std::string type                  ,
+                                                              std::string init                  );
+    public    : void             set_constant                (std::string name                  ,
                                                               uint32_t    size                  ,
                                                               std::string      init                  );
     public    : void             set_constant                (std::string      name                  ,
+                                                              std::string init                  );
+    public    : void             set_constant                (std::string name                  ,
                                                               uint32_t    size                  ,
                                                               uint32_t    init                  );
     private   : std::string           get_type                    (uint32_t    depth                 );
     public    : void             set_type                    (std::string      name                  ,
                                                               std::string      type                  );
     private   : std::string           get_alias                   (uint32_t    depth                 );
     public    : void             set_alias                   (std::string      name1                 ,
                                                               std::string      type1                 ,
                                                               std::string      name2                 ,
                                                               std::string      range2                );
     public    : void             set_alias                   (std::string      name1                 ,
+    private   : std::string      get_type                    (uint32_t    depth                 );
+    public    : void             set_type                    (std::string name                  ,
+                                                              std::string type                  );
+    private   : std::string      get_alias                   (uint32_t    depth                 );
+    public    : void             set_alias                   (std::string name1                 ,
+                                                              std::string type1                 ,
+                                                              std::string name2                 ,
+                                                              std::string range2                );
+    public    : void             set_alias                   (std::string name1                 ,
                                                               uint32_t    size1                 ,
+                                                              std::string      name2                 ,
+                                                              std::string      range2                );
+                                                              std::string name2                 ,
+                                                              std::string range2                );
+    public    : std::string      get_list                    (std::list<std::string> liste      ,
+                                                              uint32_t     depth                ,
+                                                              std::string  separator            ,
+                                                              bool         last_separator       );
+    public    : void             set_list                    (std::list<std::string> & liste    ,
+                                                              std::string  text                 );
+    public    : std::string           get_list                    (std::list<std::string> liste                ,
+                                                                   uint32_t     depth                ,
+                                                                   std::string       separator            ,
+                                                                   bool         last_separator       );
+    public    : void             set_list                    (std::list<std::string> & liste              ,
+                                                              std::string         text               );
+    private   : std::string      get_body                    (uint32_t     depth                );
+    public    : void             set_body                    (std::string  text                 );
+    public    : void             set_body                    (Vhdl *       vhdl                 );
+    public    : void             set_body_component          (std::string  name_instance        ,
+                                                              std::string  name_component       ,
+                                                              std::list<std::string>   list_port_map);
+    public    : void             set_body_component_port_map (std::list<std::string> & list_port_map,
+                                                              std::string  name_port            ,
+                                                              uint32_t     size_port            ,
+                                                              std::string  name_signal          ,
+                                                              uint32_t     size_signal          );
+    private   : std::string           get_body                    (uint32_t       depth              );
+    public    : void             set_body                    (std::string         text               );
+    private   : std::string      get_library_ieee            (uint32_t     depth                );
+    private   : std::string      get_library_work            (uint32_t     depth                );
+    public    : void             set_library_work            (std::string  package_name         );
+    public    : void        set_body_component          (std::string         name_instance      ,
+                                                         std::string         name_component     ,
+                                                         std::list<std::string>   list_port_map      );
+    public    : void        set_body_component_port_map (std::list<std::string> & list_port_map      ,
+                                                         std::string         name_port          ,
+                                                         uint32_t       size_port          ,
+                                                         std::string         name_signal        ,
+                                                         uint32_t       size_signal        );
+    private   : std::string get_library_ieee            (uint32_t    depth                 );
+    private   : std::string get_library_work            (uint32_t    depth                 );
+    public    : void        set_library_work            (std::string      package_name          );
+    private   : std::string direction_toString          (direction_t direction);
+    private   : std::string      direction_toString          (direction_t  direction            );
     };

trunk/IPs/systemC/processor/Morpheo/Behavioural/include/XML.h

-              r81
+              r88
   public   : bool             singleton_end       (void);
   public   : bool             attribut            (std::string name, std::string value);
   public   : bool             insert_XML          (XML    xml );
+  public   : bool             insert_XML          (XML    xml, uint32_t offset_depth=0);
   public   : void             filename_extension  (std::string extension);
   public   : void             generate_file       (void);
   public   : void             generate_file       (std::string encoding);
   public   : std::string           get_body            (void);
   public   : std::string           get_body            (uint32_t depth);
+  public   : void             generate_file       (std::string dirname, std::string encoding);
+  public   : void             generate_file       (std::string dirname=".");
+  public   : std::string      get_body            (void);
+  public   : std::string      get_body            (uint32_t depth);
   public   : bool             comment             (std::string text);
   public   : bool             text                (std::string text);
   private  : std::string           indent              (uint32_t depth );
   private  : std::string           indent              (void);
+  private  : std::string      indent              (uint32_t depth );
+  private  : std::string      indent              (void);
   private  : uint32_t         depth               (void);

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_generate_file.cpp

r81	r88
8	8
9	9	#include "Behavioural/include/Component.h"
	10	#include "Common/include/Environment.h"
10	11
11	12	namespace morpheo {
12	13	namespace behavioural {
13	14
	15	#undef FUNCTION
	16	#define FUNCTION "Component::generate_file"
14	17	void Component::generate_file (void)
15	18	{
…	…
18	21	try
19	22	{
	23	directory();
	24
20	25	XML xml = toXML();
21	26
22		xml.filename_extension ("pos");
	27	xml.filename_extension (".pos");
23	28
24		xml.generate_file("ISO-8859-1");
	29	xml.generate_file(MORPHEO_POSITION,"ISO-8859-1");
25	30
26	31	}
27	32	catch (ErrorMorpheo e)
28	33	{
29		throw ~~(ErrorMorpheo ("Component \""+_entity->get_name()+"\" have a bad mapping : "+e.what()~~));
	34	throw ERRORMORPHEO(FUNCTION,toString(_("Component \"%s\" have a bad mapping : %s\n")),_entity->get_name().c_str(),e.what().c_str());
30	35	}
31	36

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_port_map.cpp

r82	r88
20	20	log_printf(FUNC,Behavioural,FUNCTION,"Begin");
21	21
22		// log_printf(~~NONE~~,Behavioural,FUNCTION,"Map %s.%s with %s.%s",
	22	// log_printf(INFO,Behavioural,FUNCTION,"Map %s.%s with %s.%s",
23	23	// component_src.c_str(),
24	24	// port_src.c_str(),

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Component_test_map.cpp

-              r82
+              r88
   bool Component::test_map (bool recursive)
+  {
     log_printf(NONE,Behavioural,FUNCTION, "Test port map and interface.");
+    log_printf(INFO,Behavioural,FUNCTION, "Test port map and interface.");
     return test_map (0, recursive);
+  }
 …
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     std::string tab  = std::string(depth,'\t');
+    std::string tab  = std::string(depth,' ');
     std::string name = _entity->get_name();
     bool test_ok = true;
 …
     if (is_behavioural)
+      {
         log_printf(NONE,Behavioural,FUNCTION, "%s* Component \"%s\" is a behavioural description",tab.c_str(),name.c_str());
+        log_printf(INFO,Interface,FUNCTION, "%s* Component \"%s\" is a behavioural description",tab.c_str(),name.c_str());
+      }
     else
+      {
         log_printf(NONE,Behavioural,FUNCTION, "%s* Component \"%s\" is a structural description",tab.c_str(),name.c_str());
+        log_printf(INFO,Interface,FUNCTION, "%s* Component \"%s\" is a structural description",tab.c_str(),name.c_str());
+      }
     //  log_printf(NONE,Behavioural,FUNCTION, "%s* Test port I/O",tab.c_str());
+    //  log_printf(INFO,Behavioural,FUNCTION, "%s* Test port I/O",tab.c_str());
     test_ok &= _entity->test_map(depth+1,true,is_behavioural);
     //  log_printf(NONE,Behavioural,FUNCTION, "%s* Test all internal component",tab.c_str());
+    //  log_printf(INFO,Behavioural,FUNCTION, "%s* Test all internal component",tab.c_str());
     for (std::list<Tcomponent_t *>::iterator i= _list_component->begin();
 …
 //   bool Component::test_equi (bool recursive)
 //   {
 //     log_printf(NONE,Behavioural,FUNCTION, "Test port equi and interface.");
+//     log_printf(INFO,Behavioural,FUNCTION, "Test port equi and interface.");
 //     return test_equi (0, recursive);
 //   }

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Entity_test_map.cpp

-              r82
+              r88
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     std::string tab  = std::string(depth,'\t');
     log_printf(NONE,Behavioural,FUNCTION, "%s* Entity \"%s\"",tab.c_str(),_name.c_str());
+    std::string tab  = std::string(depth,' ');
+    log_printf(INFO,Interface,FUNCTION,"%s* Entity \"%s\"",tab.c_str(),_name.c_str());
     bool _return = _interfaces->test_map(depth+1,top_level, is_behavioural);
 …
 //     std::string tab  = std::string(depth,'\t');
 //     log_printf(NONE,Behavioural,FUNCTION, "%s* Entity \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Entity \"%s\"",tab.c_str(),_name.c_str());
 //     bool _return = _interfaces->test_equi(depth+1);

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_fifo_testbench_test.cpp

-              r81
+              r88
   std::string Interface_fifo::testbench_test (Vhdl * & vhdl,
                                          std::string   counter_name,
                                          std::string   reset_name  )
+                                              std::string   counter_name,
+                                              std::string   reset_name  )
+  {
     log_printf(FUNC,Behavioural,"testbench_test","Begin");
 …
         vhdl->set_body("");
                test_name        = testbench_test_name        (vhdl);
+                    test_name        = testbench_test_name        (vhdl);
         std::string test_name_tmp    = test_name+"_tmp";
         std::string test_name_ok     = testbench_test_ok          (vhdl);
 …
         vhdl->set_body(test_name + " <= '1' when ("+reset_name+" = '0') else "+test_name_tmp+";");
 #ifdef VHDL_TESTBENCH_ASSERT
         if (_list_cycle->empty()== false)
+          {
             vhdl->set_body("");
             vhdl->set_body("-- Assert ...");
             vhdl->set_body("");
+// #ifdef VHDL_TESTBENCH_ASSERT
+//      if (_list_cycle->empty()== false)
+//        {
+//          vhdl->set_body("");
+//          vhdl->set_body("-- Assert ...");
+//          vhdl->set_body("");
             uint32_t                 j = 0;
             std::list<uint32_t>::iterator i = _list_cycle->begin();
+//          uint32_t                 j = 0;
+//          std::list<uint32_t>::iterator i = _list_cycle->begin();
             while (i != _list_cycle->end())
+              {
                 vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '1')) report \"***** <"+_name+"> Test number "+toString(j)+" is OK     *****\" severity NOTE;");
                 vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '0')) report \"@@@@@ <"+_name+"> Test number "+toString(j)+" is KO !!! @@@@@\" severity NOTE;");
                 j++;
                 ++i;
+              }
+//          while (i != _list_cycle->end())
+//            {
+//              vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '1')) report \"***** <"+_name+"> Test number "+toString(j)+" is OK     *****\" severity NOTE;");
+//              vhdl->set_body("assert not (("+counter_name+" = "+toString(*i)+" and "+test_name+" = '0')) report \"@@@@@ <"+_name+"> Test number "+toString(j)+" is KO !!! @@@@@\" severity NOTE;");
+//              j++;
+//              ++i;
+//            }
             vhdl->set_body("");
+          }
 #endif
+//          vhdl->set_body("");
+//        }
+// #endif
+      }
 …
     return test_name;
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_set_signal.cpp

-              r81
+              r88
 namespace behavioural          {
   Signal * Interface::set_signal (std::string          name     ,
+  Signal * Interface::set_signal (std::string     name     ,
                                   direction_t     direction,
                                   uint32_t        size     ,
 …
     std::string signame = signal_name(_name, name, direction);
     Signal * sig = new Signal       (signame, direction, size, presence_port);

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interface_test_map.cpp

-              r82
+              r88
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     std::string tab  = std::string(depth,'\t');
+    std::string tab  = std::string(depth,' ');
     bool _return = true;
     log_printf(NONE,Behavioural,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
+    log_printf(INFO,Interface,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
     for (std::list<Signal*>::iterator i  = _list_signal->begin();
 …
 //     bool _return = true;
 //     log_printf(NONE,Behavioural,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Interface \"%s\"",tab.c_str(),_name.c_str());
 //     for (std::list<Signal*>::iterator i  = _list_signal->begin();

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_test_map.cpp

-              r82
+              r88
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     std::string tab  = std::string(depth,'\t');
+    std::string tab  = std::string(depth,' ');
     bool _return = true;
     log_printf(NONE,Behavioural,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
+    log_printf(INFO,Interface,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
     for (std::list<Interface_fifo*>::iterator i  = _list_interface->begin();
 …
 //     bool _return = true;
 //     log_printf(NONE,Behavioural,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Interfaces \"%s\"",tab.c_str(),_name.c_str());
 //     for (std::list<Interface_fifo*>::iterator i  = _list_interface->begin();

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Interfaces_testbench_generate_file.cpp

-              r81
+              r88
     log_printf(FUNC,Behavioural,"generate_file","Begin");
     Vhdl   * vhdl        = new Vhdl(_name+"_Testbench");
     std::string   counter     = "counter";
     Signal * clock       = this->get_clock();
     Signal * reset       = this->get_reset();
     std::string   clock_name  = clock->get_name();
     std::string   reset_name  = reset->get_name();
     uint32_t cycle       = this->get_cycle();
+    Vhdl   *    vhdl        = new Vhdl(_name+"_Testbench");
+    std::string counter     = "counter";
+    Signal *    clock       = this->get_clock();
+    Signal *    reset       = this->get_reset();
+    std::string clock_name  = clock->get_name();
+    std::string reset_name  = reset->get_name();
+    uint32_t    cycle       = this->get_cycle();
     vhdl->set_signal    (clock_name, 1, 0);
 …
     vhdl->set_body("\t\t\t"+counter+" <= "+counter+"+1;");
     vhdl->set_body("");
-    vhdl->set_body("\t\t\tassert not ("+counter+" >= "+toString(cycle)+") report \"Test OK\" severity FAILURE;");
-    vhdl->set_body("\t\t\tassert not ("+test_name+" = '0') report \"Test KO\" severity FAILURE;");
 #ifdef VHDL_TESTBENCH_ASSERT
-    vhdl->set_body("\t\t\t-- Assert ...");
     for (uint32_t cpt=0; cpt<=cycle; cpt++)
       vhdl->set_body("\t\t\tassert not ("+counter+" = "+toString(cpt)+") report \"===== Test number "+toString(cpt)+" =====\" severity NOTE;");
+    for (std::list<Interface_fifo*>::iterator it=_list_interface->begin();
+         it!=_list_interface->end();
+         ++it)
+      {
+        Vhdl * vhdl_assert = new Vhdl("");
+        (*it)->testbench_assert (vhdl_assert,counter);
+        vhdl->set_body(vhdl_assert);
+        delete vhdl_assert;
+      }
 #endif
     vhdl->set_body("");
+    vhdl->set_body("\t\t\tassert not ("+counter+" >= "+toString(cycle)+") report \"Test OK\" severity FAILURE;");
+    vhdl->set_body("\t\t\tassert not ("+test_name+" = '0') report \"Test KO\" severity FAILURE;");
     vhdl->set_body("\t\tend if;");
     vhdl->set_body("\tend if;");

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Parameters_test.cpp

r82	r88
23	23
24	24	if (x.have_error())
25		throw ~~(ErrorMorpheo ("Error(s) in parameters~~"));
	25	throw ERRORMORPHEO (FUNCTION,_("Error(s) in parameters\n"));
26	26
27	27	log_printf(FUNC,Behavioural,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_implement_group.cpp

-              r81
+              r88
             for (uint32_t i=16; i<=18; i++)
             _spr_generic [GROUP_SYSTEM_AND_CONTROL ][   i]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
+            _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  19]._user_access_mode       = SPR_ACCESS_MODE_READ_ONLY;
+            _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  19]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
             _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  20]._user_access_mode       = SPR_ACCESS_MODE_READ_ONLY_COND;
             _spr_generic [GROUP_SYSTEM_AND_CONTROL ][  20]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
 …
             _spr_generic [GROUP_DCACHE             ][   0]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
             for (uint32_t i=0; i<=5; i++)
+            for (uint32_t i=1; i<=5; i++)
+                {
             _spr_generic [GROUP_DCACHE             ][   i]._supervisor_access_mode = SPR_ACCESS_MODE_WRITE_ONLY;
 …
             _spr_generic [GROUP_ICACHE             ][   0]._supervisor_access_mode = SPR_ACCESS_MODE_READ_WRITE;
             for (uint32_t i=0; i<=3; i++)
+            for (uint32_t i=1; i<=3; i++)
+                {
             _spr_generic [GROUP_ICACHE             ][   i]._supervisor_access_mode = SPR_ACCESS_MODE_WRITE_ONLY;

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/SPR_access_mode_read_write.cpp

-              r81
+              r88
 #include "Behavioural/include/SPR_access_mode.h"
+#include "Common/include/Debug.h"
 namespace morpheo {
 …
   bool SPR_access_mode::read (spr_address_t address, Tcontrol_t SM, Tcontrol_t SUMRA)
+    {
+      if (not valid(address))
+//       log_printf(TRACE,true,"SPR_access_mode::read","address [%d][%d]",address._group,address._register);
+//       log_printf(TRACE,true,"SPR_access_mode::read","sm        : %d",SM   );
+//       log_printf(TRACE,true,"SPR_access_mode::read","sumra     : %d",SUMRA);
+      if (not exist(address))
         return false;
       spr_access_mode_t mode = _spr_generic [address._group][address._register];
+//       log_printf(TRACE,true,"SPR_access_mode::read","kernel    : %d",(int)mode._supervisor_access_mode);
+//       log_printf(TRACE,true,"SPR_access_mode::read","user      : %d",(int)mode._supervisor_access_mode);
       return (((SM == 1) and ( (mode._supervisor_access_mode == SPR_ACCESS_MODE_READ_ONLY     ) or
 …
   bool SPR_access_mode::write(spr_address_t address, Tcontrol_t SM, Tcontrol_t SUMRA)
+    {
       if (not valid(address))
+      if (not exist(address))
         return false;

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_link.cpp

r82	r88
51	51	// if (destination_have_multi_producer)
52	52	// // throw (ERRORMORPHEO (FUNCTION,"Signal \""+_name+"\" can't been linked with signal \""+signal_dest->get_name()+"\" : destination have multi producer."));
53		// log_printf(~~NONE~~,Behavioural,FUNCTION,"Signal \"%s\" can't been linked with signal \"%s\" : destination have multi producer.",_name.c_str(),signal_dest->get_name().c_str());
	53	// log_printf(INFO,Behavioural,FUNCTION,"Signal \"%s\" can't been linked with signal \"%s\" : destination have multi producer.",_name.c_str(),signal_dest->get_name().c_str());
54	54
55	55	// update info source

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Signal_test_map.cpp

-              r82
+              r88
     std::string str     = "";
     std::string tab     = std::string(depth,'\t');
+    std::string tab     = std::string(depth,' ');
     bool        _return = true;
 //     log_printf(NONE,Behavioural,FUNCTION, "%s* Signal \"%s\"",tab.c_str(),_name.c_str());
 //     log_printf(NONE,Behavioural,FUNCTION, "%s%d - %d - %d",tab.c_str(),
+//     log_printf(INFO,Behavioural,FUNCTION, "%s* Signal \"%s\"",tab.c_str(),_name.c_str());
+//     log_printf(INFO,Behavioural,FUNCTION, "%s%d - %d - %d",tab.c_str(),
 //             _is_map_as_toplevel_dest,
 //             _is_map_as_component_src,
 //             _is_map_as_component_dest);
 //     log_printf(NONE,Behavioural,FUNCTION, "%stop_level %d, is_behavioural %d",tab.c_str(),
+//     log_printf(INFO,Behavioural,FUNCTION, "%stop_level %d, is_behavioural %d",tab.c_str(),
 //             top_level,
 //             is_behavioural);
 …
     if (_return == false)
+      {
-        log_printf(NONE,Behavioural,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
 #ifndef DEBUG
         std::cerr << str << std::endl;
+#else
+        log_printf(INFO,Interface,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
 #endif
+      }
     else
+      {
 //      log_printf(NONE,Behavioural,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
+//      log_printf(INFO,Interface,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
+      }
 …
 //     if (_return == false)
 //       {
 //      log_printf(NONE,Behavioural,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
+//      log_printf(INFO,Behavioural,FUNCTION, "%s* %s",tab.c_str(),str.c_str());
 // #ifndef DEBUG
 …
 //     else
 //       {
 // //   log_printf(NONE,Behavioural,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
+// //   log_printf(INFO,Behavioural,FUNCTION, "%s* Signal \"%s\" is OK.",tab.c_str(),_name.c_str());
 //       }

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree.cpp

-              r81
+              r88
   Stat_binary_tree:: Stat_binary_tree (counter_t   cst)
+  {
+    _root  = NULL;
+    _left  = NULL;
+    _right = NULL;
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
+    data_t data;
+    data.cst = cst;
+    _data_type   = CONSTANT;
+    _data        = data;
+//     Stat_binary_tree(CONSTANT, data);
+    change_type (cst);
+  }
   Stat_binary_tree:: Stat_binary_tree (counter_t * var)
+  {
+    _root  = NULL;
+    _left  = NULL;
+    _right = NULL;
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
+    data_t data;
+    data.var   = var;
+    _data_type = VARIABLE;
+    _data      = data;
+//     Stat_binary_tree(VARIABLE, data);
+    change_type (var);
+  }
   Stat_binary_tree:: Stat_binary_tree (operator_t  op)
+  {
+    _root  = NULL;
+    _left  = NULL;
+    _right = NULL;
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
+    data_t data;
+    data.op    = op;
+    _data_type = ((op == inc) or (op == dec))?OPERATOR_UNARY:OPERATOR_BINARY;
+    _data      = data;
+    change_type (op);
+  }
+  Stat_binary_tree:: Stat_binary_tree (std::string expr,
+                                       std::map<std::string, counter_t*> * operand)
+  {
+    _root      = NULL;
+    _left      = NULL;
+    _right     = NULL;
+    _data_type = NONE;
+    import (expr, operand);
+  }

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_binary_tree_valid.cpp

-              r81
+              r88
 namespace morpheo {
 namespace behavioural {
   bool Stat_binary_tree::valid (void)
+  {
+    if (_data_type == NONE)
+      return false;
     if ((_data_type == VARIABLE) or
         (_data_type == CONSTANT))
       return ((_left  == NULL) and
               (_right == NULL) );
+              (_right == NULL) );
     if (_data_type == OPERATOR_UNARY)
       return ((_right == NULL) and
               (_left  != NULL) and
               (_left->valid()));
+              (_left  != NULL) and
+              (_left->valid()));
     if (_data_type == OPERATOR_BINARY)
       return ((_left  != NULL ) and
               (_left ->valid()) and
               (_right != NULL ) and
               (_right->valid()));
+              (_left ->valid()) and
+              (_right != NULL ) and
+              (_right->valid()));
     return false;
+  }
+  void Stat_binary_tree::print (uint32_t depth)
+  {
+    std::string tab = std::string(depth,'\t');
+    std::string sep = " ";
+    if (_data_type == NONE)
+      {
+        std::cout << tab << "<node> NONE (error)" << std::endl;
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+    if ((_data_type == VARIABLE) or
+        (_data_type == CONSTANT))
+      {
+        std::cout << tab << "<leaf>"
+                  << " "
+                  << ((_left   == NULL)?"left  == NULL        ":"left  != NULL (error)")
+                  << " "
+                  << ((_right  == NULL)?"right == NULL        ":"right != NULL (error)")
+                  << std::endl;
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+    if (_data_type == OPERATOR_UNARY)
+      {
+        std::cout << tab << "<unary>"
+                  << " "
+                  << ((_left   == NULL)?"left  == NULL (error)":"left  != NULL        ")
+                  << " "
+                  << ((_right  == NULL)?"right == NULL        ":"right != NULL (error)")
+                  << std::endl;
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+    if (_data_type == OPERATOR_BINARY)
+      {
+        std::cout << tab << "<binary>"
+                  << " "
+                  << ((_left   == NULL)?"left  == NULL (error)":"left  != NULL        ")
+                  << " "
+                  << ((_right  == NULL)?"right == NULL (error)":"right != NULL        ")
+                  << std::endl;
+        if (_left  != NULL)
+          _left ->print(depth+1);
+        if (_right != NULL)
+          _right->print(depth+1);
+      }
+  }
 };
 };

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_generate_file.cpp

-              r81
+              r88
 #include "Behavioural/include/Stat.h"
 #include "Behavioural/include/Version.h"
+#include "Common/include/Environment.h"
 namespace morpheo {
 …
   void Stat::generate_file (void)
+  {
+    directory();
     std::string body = print(1);
 …
     xml->balise_close();
     xml->filename_extension ("stat");
     xml->generate_file();
+    xml->filename_extension (".stat");
+    xml->generate_file(MORPHEO_STATISTICS);
     delete xml;

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_have_counter.cpp

-              r81
+              r88
          i!= _list_operand->end();
          ++i)
+      if (i->second.type == TYPE_COUNTER)
+        return true;
+      {
+        if (i->second.type == TYPE_COUNTER)
+          return true;
+      }
     return false;
+  }

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_print.cpp

r81	r88
7	7	std::string Stat::print (uint32_t depth)
8	8	{
	9	// log_printf(TRACE,Behavioural,"Stat::print","Component name : %s",_name_component.c_str());
	10	// log_printf(TRACE,Behavioural,"Stat::print","Instance name : %s",_name_instance .c_str());
	11
9	12	end_simulation();
10	13
…	…
21	24	stat != _list_stat->end();
22	25	stat ++)
23		xml.text((*stat)->print(1));
24
	26	{
	27	xml.text((*stat)->print(1));
	28	}
25	29
26	30	// Test special case
…	…
63	67	++operand)
64	68	{
65		if (operand->second.type == TYPE_COUNTER)
	69	if (operand->second.type == TYPE_COUNTER)
66	70	{
67	71	xml.singleton_begin(operand->second.name);
…	…
80	84	}
81	85	}
	86
82	87	xml.balise_close();
83
	88
84	89	return xml.get_body(depth);
85	90	}

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Stat_string2tree.cpp

-              r81
+              r88
 namespace behavioural {
-#define string2operator(x) (x=="+")?add:((x=="-")?sub:((x=="*")?mul:((x=="/" )?div:((x=="++")?inc:dec))))
   Stat_binary_tree * Stat::string2tree     (std::string expr)
+  {
+    const std::string delims  (" ");          // délimiteur : " "
+    const std::string numbers ("0123456789"); // délimiteur : " "
+    std::string::size_type index_begin, index_end;
+    std::map<std::string, counter_t*> * operand = new std::map<std::string, counter_t*>;
+    Stat_binary_tree * tree = NULL;
+    for (std::map<std::string, var_t>::iterator it = _list_operand->begin();
+         it != _list_operand->end();
+         ++ it)
+      (*operand) [it->first] = it->second.counter;
     index_begin = expr.find_first_not_of(delims);
+    Stat_binary_tree * tree = new Stat_binary_tree(expr,operand);
+    while (index_begin != std::string::npos)
+      {
+        index_end = expr.find_first_of(delims, index_begin);
+        if (index_end == std::string::npos)
+          {
+            index_end = expr.length();
+          }
+        std::string str = expr.substr(index_begin, index_end-index_begin);
+        // 3 possibilités :
+        //  * operator
+        //  * constante
+        //  * variable
+        {
+          // Test constantes
+          std::string::size_type index = str.find_first_not_of(numbers);
+          if (index  == std::string::npos)
+            {
+//            std::cout << " * c'est une constante." << std::endl;
+              if (tree==NULL)
+                tree = new Stat_binary_tree (atoi(str.c_str()));
+              else
+                tree = tree->insert_tree (atoi(str.c_str()));
+            }
+          else
+            {
+              // Test variables
+              std::map<std::string, var_t>::iterator it = _list_operand->find(str);
+              if (it != _list_operand->end())
+                {
+//                std::cout << " * c'est une variable." << std::endl;
+                  if (tree==NULL)
+                    tree = new Stat_binary_tree (it->second.counter);
+                  else
+                    tree = tree->insert_tree (it->second.counter);
+                }
+              else
+                {
+                  if ((str == "+") or
+                      (str == "-") or
+                      (str == "*") or
+                      (str == "/"))
+                    {
+//                    std::cout << " * c'est un operator à 2 opérandes." << std::endl;
+//                    if (tree==NULL)
+//                      tree = new Stat_binary_tree (morpheo::string2operator[str].second);
+//                    else
+//                      tree->insert_tree (morpheo::string2operator[str].second);
+                      if (tree==NULL)
+                        tree = new Stat_binary_tree (string2operator(str));
+                      else
+                        tree = tree->insert_tree (string2operator(str));
+                    }
+                  else
+                    {
+                      if ((str == "++") or
+                          (str == "--"))
+                        {
+//                        std::cout << " * c'est un operator à 1 opérande." << std::endl;
+//                        if (tree==NULL)
+//                          tree = new Stat_binary_tree (string2operator[str.c_str()]);
+//                        else
+//                          tree->insert_tree (string2operator[str.c_str()]);
+                          if (tree==NULL)
+                            tree = new Stat_binary_tree (string2operator(str));
+                          else
+                            tree = tree->insert_tree (string2operator(str));
+                        }
+                      else
+                        {
+//                        std::cout << " * c'est autre chose." << std::endl;
+                          str = "expression '"+str+"' doesn't a constant, a declarated variable or an operator.";
+                          throw(ERRORMORPHEO("Stat::string2tree",_(str.c_str())));
+                        }
+                    }
+                }
+            }
+        }
+        index_begin = expr.find_first_not_of(delims, index_end);
+        if (index_begin != std::string::npos)
+          tree = tree->goto_next_root();
+      }
+    if (tree == NULL)
+      throw (ERRORMORPHEO("Stat::string2tree",_("the tree generated is empty.")));
+//     std::cout << "<Stat::string2tree> goto_top_level" << std::endl;
+    tree = tree->goto_top_level();
+//     std::cout << "<Stat::string2tree> valid" << std::endl;
+    if (not tree->valid())
+      throw (ERRORMORPHEO("Stat::string2tree",_("the tree generated is invalid.")));
+//     std::cout << "<Stat::string2tree> End" << std::endl;
+    delete operand;
     return tree;
+  }

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Usage.cpp

-              r81
+              r88
     return ((usage & flag) != 0);
+  }
+#undef  FUNCTION
+#define FUNCTION "usage_environment"
   void     usage_environment (Tusage_t usage)
+  {
 #ifndef SYSTEMC
     if (usage_is_set(usage,USE_SYSTEMC))
       throw ErrorMorpheo(_("Component use the flag \"USE_SYSTEMC\", but the macro's compiler \"SYSTEMC\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_SYSTEMC\", but the macro's compiler \"SYSTEMC\" is unset.\n"));
 #endif
 #ifndef VHDL
     if (usage_is_set(usage,USE_VHDL))
       throw ErrorMorpheo(_("Component use the flag \"USE_VHDL\", but the macro's compiler \"VHDL\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_VHDL\", but the macro's compiler \"VHDL\" is unset.\n"));
 #endif
 #ifndef VHDL_TESTBENCH
     if (usage_is_set(usage,USE_VHDL_TESTBENCH))
       throw ErrorMorpheo(_("Component use the flag \"USE_VHDL_TESTBENCH\", but the macro's compiler \"VHDL_TESTBENCH\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_VHDL_TESTBENCH\", but the macro's compiler \"VHDL_TESTBENCH\" is unset.\n"));
 #endif
 #ifndef VHDL_TESTBENCH_ASSERT
     if (usage_is_set(usage,USE_VHDL_TESTBENCH_ASSERT))
       throw ErrorMorpheo(_("Component use the flag \"USE_VHDL_TESTBENCH_ASSERT\", but the macro's compiler \"VHDL_TESTBENCH_ASSERT\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_VHDL_TESTBENCH_ASSERT\", but the macro's compiler \"VHDL_TESTBENCH_ASSERT\" is unset.\n"));
 #endif
 #ifndef POSITION
     if (usage_is_set(usage,USE_POSITION))
       throw ErrorMorpheo(_("Component use the flag \"USE_POSITION\", but the macro's compiler \"POSITION\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_POSITION\", but the macro's compiler \"POSITION\" is unset.\n"));
 #endif
 #ifndef STATISTICS
     if (usage_is_set(usage,USE_STATISTICS))
       throw ErrorMorpheo(_("Component use the flag \"USE_STATISTICS\", but the macro's compiler \"STATISTICS\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_STATISTICS\", but the macro's compiler \"STATISTICS\" is unset.\n"));
 #endif
 #ifndef INFORMATION
     if (usage_is_set(usage,USE_INFORMATION))
       throw ErrorMorpheo(_("Component use the flag \"USE_INFORMATION\", but the macro's compiler \"INFORMATION\" is unset."));
+      throw ERRORMORPHEO(FUNCTION,_("Component use the flag \"USE_INFORMATION\", but the macro's compiler \"INFORMATION\" is unset.\n"));
 #endif
 …
     if (usage_is_set(usage,USE_STATISTICS) and not usage_is_set(usage,USE_SYSTEMC))
       throw ErrorMorpheo(_("Usage flags conflit : to use the statistics, you must set flag USE_SYSTEMC"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the statistics, you must set flag USE_SYSTEMC\n"));
     if (usage_is_set(usage,USE_INFORMATION) and not usage_is_set(usage,USE_STATISTICS))
       throw ErrorMorpheo(_("Usage flags conflit : to use the information, you must set flag USE_STATISTICS"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the information, you must set flag USE_STATISTICS\n"));
     if (usage_is_set(usage,USE_VHDL_TESTBENCH) and not usage_is_set(usage,USE_SYSTEMC))
       throw ErrorMorpheo(_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_SYSTEMC"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_SYSTEMC\n"));
     if (usage_is_set(usage,USE_VHDL_TESTBENCH) and not usage_is_set(usage,USE_VHDL))
       throw ErrorMorpheo(_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_VHDL"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use the vhdl's test bench, you must set flag USE_VHDL\n"));
     if (usage_is_set(usage,USE_VHDL_TESTBENCH_ASSERT) and not usage_is_set(usage,USE_VHDL_TESTBENCH))
       throw ErrorMorpheo(_("Usage flags conflit : to use an assert in vhdl's test bench, you must set flag USE_VHDL_TESTBENCH"));
+      throw ERRORMORPHEO(FUNCTION,_("Usage flags conflit : to use an assert in vhdl's test bench, you must set flag USE_VHDL_TESTBENCH\n"));
+  }
 …
     usage = usage_set(usage,USE_INFORMATION);
 #endif
+    usage = usage_set(usage,USE_HEADER);
 #ifdef DEBUG
 #endif

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_model.cpp

-              r81
+              r88
 #include "Behavioural/include/Vhdl.h"
+#include "Common/include/Environment.h"
 #include <sstream>
 #include <fstream>
 …
     log_printf(FUNC,Behavioural,"generate_file_model","Begin");
+    std::string filename = _name + ".vhdl";
+    directory();
+    std::string filename = MORPHEO_VHDL + "/" + _name + ".vhdl";
+    log_printf(TRACE,Behavioural,"generate_file_model","print %s",filename.c_str());
+    std::cout << "Generate file \""<< filename << "\"" << std::endl;
+    msg_printf(INFORMATION,_("Generate file \"%s\"."),filename.c_str());
     log_printf(TRACE,Behavioural,"generate_file_model","declaration");

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_generate_file_package.cpp

-              r81
+              r88
 #include "Behavioural/include/Vhdl.h"
+#include "Common/include/Environment.h"
 #include <sstream>
 #include <fstream>
 …
     log_printf(FUNC,Behavioural,"generate_file_package","Begin");
+    directory();
     std::string name     = _name + "_Pack";
     std::string filename =  name + ".vhdl";
+    std::string filename = MORPHEO_VHDL + "/" + name + ".vhdl";
     std::cout << "Generate file \""<< filename << "\"" << std::endl;
+    msg_printf(INFORMATION,_("Generate file \"%s\"."),filename.c_str());
     std::ofstream file;

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_get_header.cpp

-              r85
+              r88
     text += "-- "+toString(_("File : "))            + filename  +"\n";
     text += "-- "+toString(_("Date : "))            + ctime (&current_time );
     text += "-- "+toString(_("Morpheo version : ")) + MORPHEO_VERSION +"\n";
+    text += "-- "+toString(_("Morpheo version : ")) + MORPHEO_HEADER +"\n";
     text += "-- "+toString(_("Comment : "))         + _("it's a autogenerated file, don't modify") +"\n";
     text += "-------------------------------------------------------------------------------\n";
 …
     log_printf(FUNC,Behavioural,FUNCTION,"End");
     return text.str();
+    return text;
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/Vhdl_set_body.cpp

-              r81
+              r88
 #undef  FUNCTION
 #define FUNCTION "Vhdl::set_body"
   void Vhdl::set_body (std::string      text     )
+  void Vhdl::set_body (std::string text)
+  {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     set_list(_list_body, text);
+    log_printf(FUNC,Behavioural,FUNCTION,"End");
+  };
+#undef  FUNCTION
+#define FUNCTION "Vhdl::set_body"
+  void Vhdl::set_body (Vhdl * vhdl)
+  {
+    log_printf(FUNC,Behavioural,FUNCTION,"Begin");
+    for (std::list<std::string>::iterator it=vhdl->_list_body.begin();
+         it!=vhdl->_list_body.end();
+         ++it)
+      set_list(_list_body, *it);
     log_printf(FUNC,Behavioural,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML.cpp

r81	r88
17	17	{
18	18	log_printf(FUNC,Behavioural,FUNCTION,"Begin");
19		_filename_extension="xml";
	19	_filename_extension=".xml";
20	20	log_printf(FUNC,Behavioural,FUNCTION,"End");
21	21	};

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_generate_file.cpp

-              r81
+              r88
 #include "Behavioural/include/XML.h"
+#include "Common/include/ErrorMorpheo.h"
 #include <fstream>
 …
 #undef  FUNCTION
 #define FUNCTION "XML::generate_file"
   void XML::generate_file (std::string encoding)
+  void XML::generate_file (std::string dirname, std::string encoding)
+  {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
 …
     header (encoding);
     std::string filename =  _name + "." + _filename_extension;
+    std::string filename = dirname + "/" + _name + _filename_extension;
     std::cout << "Generate file \""<< filename << "\"" << std::endl;
+    msg_printf(INFORMATION,_("Generate file \"%s\"."),filename.c_str());
     std::ofstream file;
+    file.open(filename.c_str(),std::ios::out | std::ios::trunc);
+    file.open(filename.c_str() ,std::ios::out | std::ios::trunc);
+    if (!file)
+      throw ERRORMORPHEO(FUNCTION,toString(_("Error opening \"%s\" file.\n"),filename.c_str()));
     file << get_body();
 …
   };
   void XML::generate_file (void)
+  void XML::generate_file (std::string dirname)
+  {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     generate_file("UTF-8");
+    generate_file(dirname,"UTF-8");
     log_printf(FUNC,Behavioural,FUNCTION,"End");
   };

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_get_body.cpp

-              r83
+              r88
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     std::string body       = _body;
     std::string tabulation = indent(depth);
+    std::string body = _body;
+    std::string tab  = indent(depth);
 //  body.insert(0,tabulation);
+    body.insert(0,tab);
     for (size_t pos=body.find('\n',0); (pos<body.length()-1); pos=body.find('\n',++pos))
       body.insert(++pos,tabulation);
+      body.insert(++pos,tab);
     log_printf(FUNC,Behavioural,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_header.cpp

-              r85
+              r88
     str += "\n";
     str += "<!--\n";
     str += "\t"+toString(_("File : "))            + _name+"."+_filename_extension + "\n";
+    str += "\t"+toString(_("File : "))            + _name + _filename_extension + "\n";
     str += "\t"+toString(_("Date : "))            + ctime (&current_time );
     str += "\t"+toString(_("Morpheo version : ")) + MORPHEO_VERSION +"\n";
+    str += "\t"+toString(_("Morpheo version : ")) + MORPHEO_HEADER +"\n";
     str += "\t"+toString(_("Comment : "))         + toString(_("it's a autogenerated file, don't modify")) +"\n";
     str += "-->\n";

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_insert_XML.cpp

-              r81
+              r88
 #undef  FUNCTION
 #define FUNCTION "XML::insert_XML"
   bool XML::insert_XML (XML xml)
+  bool XML::insert_XML (XML xml, uint32_t offset_depth)
+  {
     log_printf(FUNC,Behavioural,FUNCTION,"Begin");
     //return text (xml.get_body());
     _body += xml.get_body(depth());
+    _body += xml.get_body(depth()+offset_depth);
     log_printf(FUNC,Behavioural,FUNCTION,"End");

trunk/IPs/systemC/processor/Morpheo/Behavioural/src/XML_text.cpp

r81	r88
16	16	{
17	17	log_printf(FUNC,Behavioural,FUNCTION,"Begin");
18		_body += ~~indent()+~~text; // +"\n";
	18	_body += text; // +"\n";
19	19	log_printf(FUNC,Behavioural,FUNCTION,"End");
20	20

trunk/IPs/systemC/processor/Morpheo/Common/include/Address.h

r81	r88
1		#ifndef ~~morpheo_Address~~
2		#define ~~morpheo_Address~~
	1	#ifndef Morpheo_Address_h
	2	#define Morpheo_Address_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/Average.h

r81	r88
1		#ifndef ~~morpheo_Average~~
2		#define ~~morpheo_Average~~
	1	#ifndef Morpheo_Average_h
	2	#define Morpheo_Average_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/BitManipulation.h

r81	r88
1		#ifndef ~~morpheo_BitManipulation~~
2		#define ~~morpheo_BitManipulation~~
	1	#ifndef Morpheo_BitManipulation_h
	2	#define Morpheo_BitManipulation_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/ChangeCase.h

r81	r88
1		#ifndef ~~morpheo_changecase~~
2		#define ~~morpheo_changecase~~
	1	#ifndef Morpheo_ChangeCase_h
	2	#define Morpheo_ChangeCase_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/Debug.h

-              r83
+              r88
 #ifndef DEBUG_H
 #define DEBUG_H
+#ifndef Morpheo_Debug_h
+#define Morpheo_Debug_h
 /*
 …
  *  - log_begin
  *  - log_end
+ *  - log_function
+ *  - msg_print
  *  - breakpoint
+ *
 …
 #include "Common/include/Message.h"
 #include "Behavioural/include/Debug_component.h"
 #include "Behavioural/include/Environment.h"
+#include <systemc.h>
 #include <stdio.h>
 #include <string.h>
 …
 #include <sstream>
 #include <string>
+namespace morpheo {
 enum _debug_verbosity
 …
            ( DEBUG_ ## component == true )) )                           \
         {                                                               \
+          if (DEBUG_ ## level <= DEBUG_INFO)                            \
+            {                                                           \
+              msg("%s ",MSG_INFORMATION);                               \
+            }                                                           \
+          else                                                          \
+            {                                                           \
+              msg("%s ",MSG_DEBUG);                                     \
+            }                                                           \
+                                                                        \
           if (DEBUG >= DEBUG_FUNC)                                      \
             {                                                           \
               msg(_("%s"),debug_tab().c_str());                         \
+              msg("%s",debug_tab().c_str());                            \
             }                                                           \
           if (DEBUG >= DEBUG_ALL )                                      \
 …
           if (DEBUG >= DEBUG_FUNC)                                      \
             {                                                           \
+              msg(_("<%s> "),func);                                     \
+              msg(_("In file %s, "),__FILE__);                          \
+              msg(_("at line %d " ),__LINE__);                          \
+              msg(_(": "));                                             \
+            }                                                           \
+          msg(str);                                                     \
+          msg(_("\n"));                                                 \
+          fflush (stdout);                                              \
+              msg(  "<%s> " ,func);                                     \
+              msg(_("In file %s, "),__FILE__);                          \
+              msg(_("at line %d " ),__LINE__);                          \
+              msg(  ": " );                                             \
+            }                                                           \
+          msg(str);                                                     \
+          msg("\n");                                                    \
         }                                                               \
     } while(0)
 …
     {                                                                   \
       debug_tab_inc ();                                                 \
       log_printf(FUNC,component,func,"Begin");                          \
+      log_printf(FUNC,component,func,_("Begin"));                       \
     } while(0)
 …
   do                                                                    \
     {                                                                   \
       log_printf(FUNC,component,func,"End");                            \
+      log_printf(FUNC,component,func,_("End"));                         \
       debug_tab_dec ();                                                 \
     } while(0)
 …
 #endif // DEBUG
+# define log_function(component,func,name)                              \
+  do                                                                    \
+    {                                                                   \
+      log_printf(TRACE,component,func,_("[%d] %s.%s"),static_cast<uint32_t>(sc_simulation_time()),name,func); \
+    } while(0)
+#define msg_printf(type,str...)                                         \
+  do                                                                    \
+    {                                                                   \
+      msg("%s ",MSG_ ## type);                                          \
+      msg(str);                                                         \
+      msg("\n");                                                        \
+    } while(0)
 #define breakpoint(str...)                                              \
   do                                                                    \
     {                                                                   \
+      msg(_("Breakpoint : file %s, line %d. Enter Any key to continue\n"),__FILE__,__LINE__); \
+      msg(str);                                                         \
+      fprintf(stdout,_("%s "),MSG_BREAKPOINT);                                     \
+      fprintf(stdout,_("Breakpoint in file %s, line %d.\n"),__FILE__,__LINE__);    \
+      fprintf(stdout,_("%s "),MSG_NONE);                                           \
+      fprintf(stdout,str);                                                              \
+      fprintf(stdout,_("\n"));                                                     \
+      fprintf(stdout,_("%s "),MSG_NONE);                                           \
+      fprintf(stdout,_("Enter any key to continue\n"));                            \
       getchar();                                                        \
     } while(0)
 …
     {                                                                   \
       if (x == NULL)                                                    \
         err(_("%s File %s, Line %d, this pointeur is null\n"),MSG_ERROR,__FILE__,__LINE__); \
+        err(_("File %s, Line %d, this pointeur is null\n"),__FILE__,__LINE__); \
     }                                                                   \
   while (0)
 …
 #endif
+}; // end namespace morpheo
 #endif // !DEBUG_H

trunk/IPs/systemC/processor/Morpheo/Common/include/ErrorMorpheo.h

-              r82
+              r88
 #ifndef morpheo_ErrorMorpheo
 #define morpheo_ErrorMorpheo
+#ifndef Morpheo_ErrorMorpheo_h
+#define Morpheo_ErrorMorpheo_h
 /*
 …
  */
+#include "ToString.h"
+#include "Common/include/ToString.h"
+#include "Common/include/Translation.h"
+#include "Common/include/Message.h"
 #include <iostream>
 #include <exception>
 …
     // -----[ methods ]---------------------------------------------------
   public  :             ErrorMorpheo  ()                throw() {_msg="Exception detected ...";}
   public  :             ErrorMorpheo  (std::string msg) throw() {_msg=msg;}
+  public  :             ErrorMorpheo  ()                throw() {_msg = toString("%s ",MSG_ERROR); _msg+="Exception detected ...";}
+  public  :             ErrorMorpheo  (std::string msg) throw() {_msg = toString("%s ",MSG_ERROR); _msg+=msg;}
   public  :             ErrorMorpheo  (std::string funcname,
                                        std::string msg     ,
 …
                                        std::string file    ) throw()
+    {
+      _msg = toString("<%s> at line %d, in file %s : %s",funcname.c_str(),line,file.c_str(),msg.c_str());
+#ifdef DEBUG
+      _msg = toString(_("%s <%s> at line %d, in file %s : %s"),MSG_ERROR,funcname.c_str(),line,file.c_str(),msg.c_str());
+#else
+      _msg = toString(_("%s %s"),MSG_ERROR,msg.c_str());
+#endif
+    }
   public  :             ~ErrorMorpheo (void)       throw() {}
 …
     // -----[ methods ]---------------------------------------------------
   public  :             TestMorpheo   ()                throw() {_msg="Test error ...";}
+  public  :             TestMorpheo   ()                throw() {_msg=_("Test error ...");}
   public  :             TestMorpheo   (std::string msg) throw() {_msg=msg;}
   public  :             ~TestMorpheo  (void)            throw() {}

trunk/IPs/systemC/processor/Morpheo/Common/include/FromString.h

-              r81
+              r88
 #ifndef morpheo_fromstring
 #define morpheo_fromstring
+#ifndef Morpheo_FromString_h
+#define Morpheo_FromString_h
 /*
 …
+  }
+  template<>           inline uint64_t fromString<uint64_t>   (const std::string& x)
+  {
+    return static_cast<uint64_t>(atoll(x.c_str()));
+  }
+  template<>           inline double   fromString<double>     (const std::string& x)
+  {
+    return static_cast<double>(atof(x.c_str()));
+  }
   template<>           inline bool     fromString<bool>       (const std::string& x)
+  {

trunk/IPs/systemC/processor/Morpheo/Common/include/Log2.h

r81	r88
1		#ifndef ~~morpheo_Log2~~
2		#define ~~morpheo_Log2~~
	1	#ifndef Morpheo_Log2_h
	2	#define Morpheo_Log2_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/Max.h

-              r87
+              r88
 #ifndef morpheo_max
 #define morpheo_max
+#ifndef Morpheo_Max_h
+#define Morpheo_Max_h
 /*
 …
 namespace morpheo {
   template<typename T> inline T max (const T * x, uint32_t size)
+  template<typename T> inline T max (T * x, uint32_t size)
+  {
     T res = x[0];
     for (uint32_t i=1; i<size; i++)
+      if (res<x[i])
+        res = x[i];
+      {
+        T tmp = x[i];
+        if (res<tmp)
+          res = tmp;
+      }
     return res;
+  }
+  template<typename T> inline T max (const T * x, uint32_t size, uint32_t n)
+  template<typename T> inline T max (T ** x, uint32_t size1, uint32_t size2)
+  {
+    T res = max(x[0],size2);
+    for (uint32_t i=1; i<size1; i++)
+      {
+        T tmp = max(x[i],size2);
+        if (res<tmp)
+          res = tmp;
+      }
+    return res;
+  }
+  template<typename T> inline T max (T ** x, uint32_t size1, uint32_t * size2)
+  {
+    T res = max(x[0],size2[0]);
+    for (uint32_t i=1; i<size1; i++)
+      {
+        T tmp = max(x[i],size2[i]);
+        if (res<tmp)
+          res = tmp;
+      }
+    return res;
+  }
+  template<typename T> inline T max (T * x, uint32_t size, uint32_t n)
+  {
     if ((n==0) or (n>size))

trunk/IPs/systemC/processor/Morpheo/Common/include/Message.h

-              r83
+              r88
 #ifndef MESSAGE_H
 #define MESSAGE_H
+#ifndef Morpheo_Message_h
+#define Morpheo_Message_h
 /*
  * $Id$
 …
 namespace morpheo {
+#define MSG_ERROR         _("[   ERROR   ]")
+#define MSG_WARNING       _("[  WARNING  ]")
+#define MSG_INFORMATION   _("[INFORMATION]")
+  // Color
+  // 31 : rouge
+  // 32 : vert
+  // 33 : jaune
+  // 34 : bleu
+  // 35 : rose
+  // 36 : cyan
+  // 37 : blanc
+  // 38 : noir souligne
+  // 39 : noir
+#define msg(arg...)                             \
+#  define MSG_NONE          _("             ")
+#ifdef PRINT_COLOR
+#  define MSG_DEBUG         _("[1;34m[   DEBUG   ][0m")
+#  define MSG_ERROR         _("[1;31m[   ERROR   ][0m")
+#  define MSG_WARNING       _("[1;35m[  WARNING  ][0m")
+#  define MSG_INFORMATION   _("[1;32m[INFORMATION][0m")
+#  define MSG_BREAKPOINT    _("[1;38m[   BREAK   ][0m")
+#else
+#  define MSG_DEBUG         _("[   DEBUG   ]")
+#  define MSG_ERROR         _("[   ERROR   ]")
+#  define MSG_WARNING       _("[  WARNING  ]")
+#  define MSG_INFORMATION   _("[INFORMATION]")
+#  define MSG_BREAKPOINT    _("[   BREAK   ]")
+#endif
+#ifdef LOG_FILE
+extern FILE * log_stream;
+void log_init (void);
+#define fmsg(stream,arg...)                     \
   do                                            \
     {                                           \
+      fprintf(stdout,arg);                      \
+      log_init();                               \
+      fprintf(log_stream,arg);                  \
+      fflush(log_stream);                       \
+    } while (0)
+#else
+#define fmsg(stream,arg...)                     \
+  do                                            \
+    {                                           \
+      fprintf(stream,arg);                      \
+      fflush(stream);                           \
     } while (0)
+#define err(arg...)                             \
+#endif
+#define fmsgDebug(stream,arg...)                \
   do                                            \
     {                                           \
+      fprintf(stderr,arg);                      \
+      fmsg(stream,"%s ",MSG_DEBUG);             \
+      fmsg(stream,arg);                         \
     } while (0)
+#define fmsgError(stream,arg...)                \
+  do                                            \
+    {                                           \
+      fmsg(stream,"%s ",MSG_ERROR);             \
+      fmsg(stream,arg);                         \
+    } while (0)
+#define fmsgWarning(stream,arg...)              \
+  do                                            \
+    {                                           \
+      fmsg(stream,"%s ",MSG_WARNING);           \
+      fmsg(stream,arg);                         \
+    } while (0)
+#define fmsgInformation(stream,arg...)          \
+  do                                            \
+    {                                           \
+      fmsg(stream,"%s ",MSG_INFORMATION);       \
+      fmsg(stream,arg);                         \
+    } while (0)
+#define msg(arg...)             fmsg(stdout,arg)
+#define msgDebug(arg...)        fmsgDebug(stdout,arg)
+#define msgError(arg...)        fmsgError(stdout,arg)
+#define msgWarning(arg...)      fmsgWarning(stdout,arg)
+#define msgInformation(arg...)  fmsgInformation(stdout,arg)
+#define err(arg...)             fmsgError(stderr,arg)
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Common/include/Percent.h

r81	r88
1		#ifndef ~~morpheo_Percent~~
2		#define ~~morpheo_Percent~~
	1	#ifndef Morpheo_Percent_h
	2	#define Morpheo_Percent_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/Test.h

-              r83
+              r88
+#ifndef TEST_H
+#define TEST_H
+#ifndef Morpheo_Test_h
+#define Morpheo_Test_h
+/*
+ * $Id$
+ *
+ * [ Description ]
+ *
+ * Macro / function to test
+ */
 #include <iostream>
 …
 namespace morpheo {
+//-----[ Routine de test ]---------------------------------------
+#define STR_OK "Test OK"
+#define STR_KO "Test KO"
 static uint32_t num_test;
 …
 inline void test_ko (char * file, uint32_t line, T exp1, T exp2)
+{
+  std::cerr << "[" << num_test << "] : Test KO"
+  fflush (stdout);
+  fflush (stderr);
+  std::cerr << "[" << num_test << "] : " << STR_KO
        << "\tline " << line                      << std::endl
        << " * Localisation"                      << std::endl
 …
 inline void test_ko (char * file, uint32_t line)
+{
+  std::cerr << "[" << num_test << "] : Test KO"
+  fflush (stdout);
+  fflush (stderr);
+  std::cerr << "[" << num_test << "] : " << STR_KO
        << "\tline " << line                           << std::endl
        << " * Localisation"                           << std::endl
 …
 inline void test_ok ()
+{
+  msg (_("[%d] : Test OK\n"), num_test);
+  fflush (stdout);
+  fflush (stderr);
+  msg (_("[%d] : %s\n"), num_test,STR_OK);
   num_test ++;
 …
 inline void test_ok (char * file, uint32_t line)
+{
+  msg (_("[%d] : Test OK\n"), num_test);
+  fflush (stdout);
+  fflush (stderr);
+  msg (_("[%d] : %s\n"), num_test,STR_OK);
   msg (_("\tline %d\n"), line);
 …
 inline void test_ok (char * file, uint32_t line, T exp)
+{
+  msg (_("[%d] : Test OK\n"), num_test);
+  fflush (stdout);
+  fflush (stderr);
+  msg (_("[%d] : %s\n"), num_test, STR_OK);
   msg (_("\tline %d\n"), line);
   msg (_("\tvalue %s\n"), (morpheo::toString(exp)).c_str());
 …
     msg (str);                                                          \
     msg (_("\n"));                                                      \
+    fflush (stdout);                                                    \
   } while(0)
 #ifndef CYCLE_MAX
 …
         }                                                               \
+                                                                        \
       if (cycle_current > CYCLE_MAX)                                    \
+      if ((CYCLE_MAX != 0) and (cycle_current > CYCLE_MAX))             \
         {                                                               \
           TEST_KO("Maximal cycles Reached");                            \

trunk/IPs/systemC/processor/Morpheo/Common/include/Time.h

-              r81
+              r88
 #ifndef TIME_H
 #define TIME_H
+#ifndef Morpheo_Time_h
+#define Morpheo_Time_h
 #ifdef SYSTEMC
 …
 #include <sys/time.h>
+namespace morpheo {
 class Time
+{
+private : timeval time_begin;
+#ifdef SYSTEMC
+private : double   nb_cycles_begin;
+#endif
+private : timeval  time_begin;
 // private : timeval time_end;
 public  : Time ()
+  {
+    gettimeofday(&time_begin     ,NULL);
+  {
+#ifdef SYSTEMC
+    nb_cycles_begin = sc_simulation_time();
+#endif
+    gettimeofday(&time_begin,NULL);
   };
 public  : ~Time ()
+  {
 …
   };
 public  : friend std::ostream& operator<< (std::ostream& output_stream,
+public  : friend std::ostream& operator<< (std::ostream& output,
                                            const Time & x)
+  {
     timeval time_end;
     gettimeofday(&time_end       ,NULL);
+    gettimeofday(&time_end,NULL);
+    uint32_t nb_cycles = static_cast<uint32_t>(sc_simulation_time());
     double average = static_cast<double>(nb_cycles) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec+1);
+#ifdef SYSTEMC
+    double nb_cycles_end = sc_simulation_time();
+    double average       = static_cast<double>(nb_cycles_end-x.nb_cycles_begin+1) / static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec+1);
+    output_stream << "Timing : " << nb_cycles << " cycles \t(" << average << " cycles/s)" << std::endl;
+    return output_stream;
+    output << "Timing : " << nb_cycles_end << " cycles \t(" << average << " cycles/s)" << std::endl;
+#else
+    double average       = static_cast<double>(time_end.tv_sec-x.time_begin.tv_sec+1);
+    output << "Timing : " average << " s" << std::endl;
+#endif
+    return output;
+  }
 };
+}; // end namespace morpheo
 #endif

trunk/IPs/systemC/processor/Morpheo/Common/include/ToBase2.h

r81	r88
1		#ifndef ~~morpheo_ToBase2~~
2		#define ~~morpheo_ToBase2~~
	1	#ifndef Morpheo_ToBase2_h
	2	#define Morpheo_ToBase2_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/ToString.h

r82	r88
1		#ifndef ~~morpheo_tostring~~
2		#define ~~morpheo_tostring~~
	1	#ifndef Morpheo_ToString_h
	2	#define Morpheo_ToString_h
3	3
4	4	/*

trunk/IPs/systemC/processor/Morpheo/Common/include/Translation.h

-              r82
+              r88
 #ifndef morpheo_Translation_H
 #define morpheo_Translation_H
+#ifndef Morpheo_Translation_h
+#define Morpheo_Translation_h
 /*
  * $Id$
 …
 #define MORPHEO_PACKAGE "morpheo"
+#ifdef NO_TRANSLATION
+#ifdef TRANSLATION
+# define _(str) dgettext (MORPHEO_PACKAGE,str)
+#else
 # define _(str) (str)
-#else
-# define _(str) dgettext (MORPHEO_PACKAGE,str)
 #endif
 namespace morpheo
+{
+  class Translation
+  {
+  public :  Translation (void);
+  public : ~Translation (void);
+  };
+  void translation (void);
 }; // end namespace morpheo
 #endif

trunk/IPs/systemC/processor/Morpheo/Common/include/Types.h

-              r81
+              r88
 #ifndef morpheo_Type
 #define morpheo_Type
+#ifndef Morpheo_Type_h
+#define Morpheo_Type_h
 /*
 …
 // #endif
 #define SC_CLOCK                 sc_in_clk
 // #define SC_INTERNAL(type)        type
 // #define SC_REGISTER(type)        sc_signal<type >
 // #define SC_SIGNAL(type)          sc_signal<type >
 #define SC_IN(type)              sc_in    <type >
 #define SC_OUT(type)             sc_out   <type >
+#  define SC_CLOCK                 sc_in_clk
+//#define SC_INTERNAL(type)        type
+//#define SC_REGISTER(type)        sc_signal<type >
+//#define SC_SIGNAL(type)          sc_signal<type >
+#  define SC_IN(type)              sc_in    <type >
+#  define SC_OUT(type)             sc_out   <type >
 #define PORT_READ(sig)           sig->read()
 #define PORT_WRITE(sig,val)      sig->write(val)
 // #define INTERNAL_READ(sig)       (*sig)
 // #define INTERNAL_WRITE(sig,val)  (*sig) = val
 // #define SIGNAL_READ(sig)         sig->read()
 // #define SIGNAL_WRITE(sig,val)    sig->write(val)
 // #define REGISTER_READ(sig)       sig->read()
 // #define REGISTER_WRITE(sig,val)  sig->write(val)
+#  define PORT_READ(sig)           sig->read()
+#  define PORT_WRITE(sig,val)      sig->write(val)
+//#define INTERNAL_READ(sig)       (*sig)
+//#define INTERNAL_WRITE(sig,val)  (*sig) = val
+//#define SIGNAL_READ(sig)         sig->read()
+//#define SIGNAL_WRITE(sig,val)    sig->write(val)
+//#define REGISTER_READ(sig)       sig->read()
+//#define REGISTER_WRITE(sig,val)  sig->write(val)
 #endif

trunk/IPs/systemC/processor/Morpheo/Common/src/Debug.cpp

r82	r88
7	7
8	8	#include "Common/include/Debug.h"
	9	#include "Common/include/Environment.h"
	10
	11	namespace morpheo {
9	12
10	13	static uint32_t _debug_depth = 0;
11	14
	15	#undef FUNCTION
	16	#define FUNCTION "debug_tab"
12	17	std::string debug_tab (void)
13	18	{
…	…
15	20	}
16	21
	22	#undef FUNCTION
	23	#define FUNCTION "debug_tab_inc"
17	24	void debug_tab_inc (void)
18	25	{
…	…
20	27	}
21	28
	29	#undef FUNCTION
	30	#define FUNCTION "debug_tab_dec"
22	31	void debug_tab_dec (void)
23	32	{
24	33	// _debug_depth --;
25	34	}
	35
	36	}; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Common/src/Translation.cpp

-              r82
+              r88
  */
+#include "../include/Translation.h"
+#include "../include/ErrorMorpheo.h"
+#include "Common/include/Environment.h"
+#include "Common/include/Translation.h"
+#include "Common/include/ErrorMorpheo.h"
 namespace morpheo {
+  Translation:: Translation (void)
+  static bool translation_initialized;
+  void translation (void)
+  {
+#ifndef NO_TRANSLATION
+    char * top_level = getenv("MORPHEO_TOPLEVEL");
+    if (top_level == NULL)
+      throw ERRORMORPHEO("Translation","Error morpheo environment is not positioned\n");
+    std::string dirname = top_level;
+    dirname += "IPs/systemC/processor/Morpheo/locale";
+#ifdef TRANSLATION
+    if (not translation_initialized)
+      {
+        environment();
+        std::string dirname = MORPHEO_TOPLEVEL;
+        dirname += "/IPs/systemC/processor/Morpheo/locale";
+    bindtextdomain(MORPHEO_PACKAGE,dirname.c_str());
+        if (bindtextdomain(MORPHEO_PACKAGE,dirname.c_str()) == NULL)
+          throw ERRORMORPHEO("Translation","Error in set directory containing message catalogs.\n");
+        translation_initialized = true;
+      }
 #endif
+  }
-  Translation::~Translation (void)
+  {
+  }
 }; // end namespace morpheo

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Include/doc-style.sty

r82	r88
14	14	\usepackage[latin1]{inputenc} % Pour utiliser les caractères accentués dans votre texte
15	15	\usepackage{openbib}
16		\usepackage[draft]{fixme}
	16	%\usepackage[draft]{fixme}
17	17	\bibliographystyle{plain}
18	18

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Makefile

-              r84
+              r88
 DIR_SCHEMA_PNG          = Schema_png
 DIR_TEX                 = Source
-DIR_LINK                = Link
 #--------------------------------------------------------------------------------
 …
                         $(DVIPS) -o $@ $<;
-#$(DIR_LINK)/%/*
 %.dvi                   : $(DIR_TEX)/%.tex
                         @\
 …
                         $(MKDIR) $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG);                                   \
+                                                                                                                \
-                        $(ECHO) "Create link      : $(DIR_LINK)/$$FILENAME-$(DEFAULT_LANG)";                    \
-                        $(LINK_SYMBOLIC) $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG) $(DIR_LINK)/$$FILENAME-$(DEFAULT_LANG); \
+                                                                                                                \
                         $(ECHO) "Create file      : $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG)/root.tex";      \
                         $(TOUCH) $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG)/root.tex
 …
+                                                                                                                \
                         $(ECHO) "Delete directory : $(DIR_DOCUMENTS)/$$FILENAME";                               \
+                        $(RM) $(DIR_DOCUMENTS)/$$FILENAME;                                                      \
+                        $(ECHO) "Delete link      : $(DIR_DOCUMENTS)/$$FILENAME";                               \
+                        $(RM) $(DIR_LINK)/$$FILENAME-*;
+                        $(RM) $(DIR_DOCUMENTS)/$$FILENAME;
 rename                  :
 …
+                                                                                                                \
                         $(ECHO) "Rename directory : $(DIR_DOCUMENTS)/$$FILENAME_SRC";                           \
+                        $(MV) $(DIR_DOCUMENTS)/$$FILENAME_SRC     $(DIR_DOCUMENTS)/$$FILENAME_DEST;             \
+                        $(ECHO) "Rename link      : manually please";
+                        $(MV) $(DIR_DOCUMENTS)/$$FILENAME_SRC     $(DIR_DOCUMENTS)/$$FILENAME_DEST;

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Schema/MORPHEO_micro_architecture-ex01.fig

-              r81
+              r88
 4140 4770 4140 4770 3690 5490 3690 5490 4140
 1 0 50 -1 -1 12 0.0000 4 135 450 5130 3960 decod\001
--6
-4770 3240 5490 3690
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-3690 4770 3690 4770 3240 5490 3240 5490 3690
-1 0 50 -1 -1 12 0.0000 4 105 570 5130 3420 context\001
-1 0 50 -1 -1 12 0.0000 4 105 390 5130 3600 state\001
 -6
 5850 3690 6570 4140
 …
 1 0 50 -1 -1 12 0.0000 4 135 540 10170 2655 dcache\001
 -6
-6570 3015 7290 3465
-4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
-3465 6570 3465 6570 3015 7290 3015 7290 3465
-1 0 50 -1 -1 12 0.0000 4 135 555 6930 3285 commit\001
--6
 3825 3060 4635 3510
 4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 …
 1 0 50 -1 -1 12 0.0000 4 150 300 2250 4050 port\001
 1 0 50 -1 -1 12 0.0000 4 135 495 2250 3870 icache\001
+-6
+4770 3240 5490 3690
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+3690 4770 3690 4770 3240 5490 3240 5490 3690
+1 0 50 -1 -1 12 0.0000 4 105 570 5130 3420 context\001
+1 0 50 -1 -1 12 0.0000 4 105 390 5130 3600 state\001
 -6
 1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 0 4
 …
 0 1.00 60.00 120.00
 4050 4770 4050
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+3465 6570 3465 6570 3015 7290 3015 7290 3465
 1 0 50 -1 -1 12 0.0000 4 180 585 10170 4905 register\001
 1 0 50 -1 -1 12 1.5708 4 135 465 10935 3915 select\001
 …
 1 0 50 -1 -1 12 0.0000 4 105 600 10170 4230 execute\001
 1 0 50 -1 -1 12 0.0000 4 135 600 10170 3690 memory\001
+1 0 50 -1 -1 12 0.0000 4 135 555 6930 3285 commit\001

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Schema/MORPHEO_micro_architecture-ex02.fig

-              r81
+              r88
 1 0 50 -1 -1 12 0.0000 4 135 540 10170 2655 dcache\001
 -6
-6570 3015 7290 3465
-4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
-3465 6570 3465 6570 3015 7290 3015 7290 3465
-1 0 50 -1 -1 12 0.0000 4 135 555 6930 3285 commit\001
--6
 4770 3285 5490 3735
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 …
 1 0 50 -1 -1 12 0.0000 4 135 450 5130 3555 decod\001
 -6
+3825 2655 4635 3105
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+3105 3870 3105 3870 2655 4590 2655 4590 3105
+1 0 50 -1 -1 12 0.0000 4 180 675 4230 2925 predictor\001
+-6
+2970 3285 3690 3735
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+3735 2970 3735 2970 3285 3690 3285 3690 3735
+1 0 50 -1 -1 12 0.0000 4 135 390 3330 3555 fetch\001
+-6
+1890 3690 2610 4140
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4140 1890 4140 1890 3690 2610 3690 2610 4140
+1 0 50 -1 -1 12 0.0000 4 150 300 2250 4050 port\001
+1 0 50 -1 -1 12 0.0000 4 135 495 2250 3870 icache\001
+-6
 4770 2835 5490 3285
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 3285 4770 3285 4770 2835 5490 2835 5490 3285
 1 0 50 -1 -1 12 0.0000 4 105 570 5130 3015 context\001
 1 0 50 -1 -1 12 0.0000 4 105 390 5130 3195 state\001
--6
-3825 2655 4635 3105
-4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
-3105 3870 3105 3870 2655 4590 2655 4590 3105
-1 0 50 -1 -1 12 0.0000 4 180 675 4230 2925 predictor\001
--6
-2970 3285 3690 3735
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-3735 2970 3735 2970 3285 3690 3285 3690 3735
-1 0 50 -1 -1 12 0.0000 4 135 390 3330 3555 fetch\001
--6
-1890 3690 2610 4140
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-4140 1890 4140 1890 3690 2610 3690 2610 4140
-1 0 50 -1 -1 12 0.0000 4 150 300 2250 4050 port\001
-1 0 50 -1 -1 12 0.0000 4 135 495 2250 3870 icache\001
 -6
 1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 0 3
 …
 5535 12510 5535 12510 2295 1710 2295 1710 5535
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4095 4770 4095 4770 4545 5490 4545 5490 4095
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+4725 3870 4725 3870 5175 4590 5175 4590 4725
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4095 2970 4095 2970 4545 3690 4545 3690 4095
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+3465 6570 3465 6570 3015 7290 3015 7290 3465
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 4545 4770 4545 4770 4995 5490 4995 5490 4545
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-4095 4770 4095 4770 4545 5490 4545 5490 4095
-4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
-4725 3870 4725 3870 5175 4590 5175 4590 4725
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-4095 2970 4095 2970 4545 3690 4545 3690 4095
 1 0 50 -1 -1 12 0.0000 4 180 585 10170 4905 register\001
 1 0 50 -1 -1 12 1.5708 4 135 465 10935 3915 select\001
 …
 1 0 50 -1 -1 12 0.0000 4 105 570 5130 4860 context\001
 1 0 50 -1 -1 12 0.0000 4 180 675 4230 4995 predictor\001
+1 0 50 -1 -1 12 0.0000 4 135 555 6930 3285 commit\001

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Schema/MORPHEO_micro_architecture-ex03.fig

-              r81
+              r88
 1 0 50 -1 -1 12 0.0000 4 135 540 10170 7695 dcache\001
 -6
-1890 3600 7650 6660
 5850 4995 6570 5445
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 …
 1 0 50 -1 -1 12 0.0000 4 90 555 6210 5265 rename\001
 -6
-6570 4320 7290 4770
-4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
-4770 6570 4770 6570 4320 7290 4320 7290 4770
-1 0 50 -1 -1 12 0.0000 4 135 555 6930 4590 commit\001
--6
 4770 4590 5490 5040
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 …
 1 0 50 -1 -1 12 0.0000 4 135 450 5130 4860 decod\001
 -6
+3825 3960 4635 4410
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+4410 3870 4410 3870 3960 4590 3960 4590 4410
+1 0 50 -1 -1 12 0.0000 4 180 675 4230 4230 predictor\001
+-6
+2970 4590 3690 5040
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5040 2970 5040 2970 4590 3690 4590 3690 5040
+1 0 50 -1 -1 12 0.0000 4 135 390 3330 4860 fetch\001
+-6
+1890 4995 2610 5445
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5445 1890 5445 1890 4995 2610 4995 2610 5445
+1 0 50 -1 -1 12 0.0000 4 150 300 2250 5355 port\001
+1 0 50 -1 -1 12 0.0000 4 135 495 2250 5175 icache\001
+-6
 4770 4140 5490 4590
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 4590 4770 4590 4770 4140 5490 4140 5490 4590
 1 0 50 -1 -1 12 0.0000 4 105 570 5130 4320 context\001
 1 0 50 -1 -1 12 0.0000 4 105 390 5130 4500 state\001
 -6
+3825 3960 4635 4410
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+4410 3870 4410 3870 3960 4590 3960 4590 4410
+1 0 50 -1 -1 12 0.0000 4 180 675 4230 4230 predictor\001
+-6
+2970 4590 3690 5040
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5040 2970 5040 2970 4590 3690 4590 3690 5040
+1 0 50 -1 -1 12 0.0000 4 135 390 3330 4860 fetch\001
+-6
+1890 4995 2610 5445
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5445 1890 5445 1890 4995 2610 4995 2610 5445
+1 0 50 -1 -1 12 0.0000 4 150 300 2250 5355 port\001
+1 0 50 -1 -1 12 0.0000 4 135 495 2250 5175 icache\001
+-6
+1 0 1 0 7 50 -1 20 3.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+3915 8370 3915
+1 0 1 0 7 50 -1 -1 3.000 0 0 -1 1 0 4
+0 1.00 60.00 120.00
+3915 12150 3915 12150 3240 8010 3240
+1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 1 2
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+2925 10170 3420
+1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 1 2
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+7020 10170 7515
+2 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 5
+8145 12510 8145 12510 2295 1710 2295 1710 8145
+4 0 1 0 7 50 -1 20 3.000 0 0 8 0 0 5
+2880 8010 7560 7650 7560 7650 2880 8010 2880
+1 0 1 0 7 50 -1 20 3.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+6525 8370 6525
+1 0 1 0 7 50 -1 -1 3.000 0 0 -1 1 0 4
+0 1.00 60.00 120.00
+6525 12150 6525 12150 7200 8010 7200
 1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 0 3
 0 1.00 60.00 120.00
 …
 4320 6930 4095 6030 4095 5130 3645 5130 4140
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5400 4770 5400 4770 5850 5490 5850 5490 5400
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+6030 3870 6030 3870 6480 4590 6480 4590 6030
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5400 2970 5400 2970 5850 3690 5850 3690 5400
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+4770 6570 4770 6570 4320 7290 4320 7290 4770
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 5850 4770 5850 4770 6300 5490 6300 5490 5850
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5400 4770 5400 4770 5850 5490 5850 5490 5400
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+6030 3870 6030 3870 6480 4590 6480 4590 6030
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+5400 2970 5400 2970 5850 3690 5850 3690 5400
+0 1 50 -1 -1 12 0.0000 4 135 360 1710 2205 Core\001
+0 1 50 -1 -1 12 0.0000 4 180 1185 8190 3015 Execution Loop\001
+1 0 50 -1 -1 12 1.5708 4 135 465 7875 5220 select\001
 0 1 50 -1 -1 12 0.0000 4 180 1575 5760 3825 Out Of Order Engine\001
 0 1 50 -1 -1 12 0.0000 4 135 750 2790 3735 Front End\001
 …
 1 0 50 -1 -1 12 0.0000 4 105 570 5130 6165 context\001
 1 0 50 -1 -1 12 0.0000 4 180 675 4230 6300 predictor\001
+-6
+1 0 1 0 7 50 -1 20 3.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+3915 8370 3915
+1 0 1 0 7 50 -1 -1 3.000 0 0 -1 1 0 4
+0 1.00 60.00 120.00
+3915 12150 3915 12150 3240 8010 3240
+1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 1 2
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+2925 10170 3420
+1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 1 2
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+7020 10170 7515
+2 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 5
+8145 12510 8145 12510 2295 1710 2295 1710 8145
+4 0 1 0 7 50 -1 20 3.000 0 0 8 0 0 5
+2880 8010 7560 7650 7560 7650 2880 8010 2880
+1 0 1 0 7 50 -1 20 3.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+6525 8370 6525
+1 0 1 0 7 50 -1 -1 3.000 0 0 -1 1 0 4
+0 1.00 60.00 120.00
+6525 12150 6525 12150 7200 8010 7200
+0 1 50 -1 -1 12 0.0000 4 135 360 1710 2205 Core\001
+0 1 50 -1 -1 12 0.0000 4 180 1185 8190 3015 Execution Loop\001
+1 0 50 -1 -1 12 1.5708 4 135 465 7875 5220 select\001
+1 0 50 -1 -1 12 0.0000 4 135 555 6930 4590 commit\001

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Schema/MORPHEO_micro_architecture-ex04.fig

-              r81
+              r88
 4320 5760 4320 5760 2610 7470 2610 7470 4320
 -6
+2790 2880 5580 4320
+1890 6300 2610 6750
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+6750 1890 6750 1890 6300 2610 6300 2610 6750
+1 0 50 -1 -1 12 0.0000 4 150 300 2250 6660 port\001
+1 0 50 -1 -1 12 0.0000 4 135 495 2250 6480 icache\001
+-6
 4770 3690 5490 4140
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 …
 1 0 50 -1 -1 12 0.0000 4 135 450 5130 3960 decod\001
 -6
+3825 3060 4635 3510
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+3510 3870 3510 3870 3060 4590 3060 4590 3510
+1 0 50 -1 -1 12 0.0000 4 180 675 4230 3330 predictor\001
+-6
+2970 3690 3690 4140
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4140 2970 4140 2970 3690 3690 3690 3690 4140
+1 0 50 -1 -1 12 0.0000 4 135 390 3330 3960 fetch\001
+-6
 4770 3240 5490 3690
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 3690 4770 3690 4770 3240 5490 3240 5490 3690
 1 0 50 -1 -1 12 0.0000 4 105 570 5130 3420 context\001
 1 0 50 -1 -1 12 0.0000 4 105 390 5130 3600 state\001
--6
-3825 3060 4635 3510
-4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
-3510 3870 3510 3870 3060 4590 3060 4590 3510
-1 0 50 -1 -1 12 0.0000 4 180 675 4230 3330 predictor\001
--6
-2970 3690 3690 4140
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-4140 2970 4140 2970 3690 3690 3690 3690 4140
-1 0 50 -1 -1 12 0.0000 4 135 390 3330 3960 fetch\001
--6
-1 0 1 0 31 50 -1 -1 4.000 0 0 -1 1 1 3
-0 1.00 60.00 120.00
-0 1.00 60.00 120.00
-3510 4410 3870 4770 3870
-1 0 1 0 31 50 -1 -1 4.000 0 0 -1 1 1 3
-0 1.00 60.00 120.00
-0 1.00 60.00 120.00
-3510 4050 3870 3690 3870
-1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
-0 1.00 60.00 120.00
-3960 4770 3960
-4 0 1 0 11 51 -1 20 0.000 0 0 7 0 0 5
-4050 3060 4050 3060 3600 3780 3600 3780 4050
-1 0 1 0 31 50 -1 -1 4.000 0 0 -1 1 1 3
-0 1.00 60.00 120.00
-0 1.00 60.00 120.00
-3510 3960 3780 3780 3780
-1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
-0 1.00 60.00 120.00
-4050 4770 4050
-2 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 5
-2880 2790 2880 2790 4320 5580 4320 5580 2880
--6
-1890 6300 2610 6750
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-6750 1890 6750 1890 6300 2610 6300 2610 6750
-1 0 50 -1 -1 12 0.0000 4 150 300 2250 6660 port\001
-1 0 50 -1 -1 12 0.0000 4 135 495 2250 6480 icache\001
 -6
 1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 0 3
 …
 6390 4770 6390
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-6750 4770 6750 4770 7200 5490 7200 5490 6750
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 6300 4770 6300 4770 6750 5490 6750 5490 6300
 4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 …
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 6300 5850 6300 5850 6750 6570 6750 6570 6300
+1 0 1 0 31 50 -1 -1 4.000 0 0 -1 1 1 3
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+3510 4410 3870 4770 3870
+1 0 1 0 31 50 -1 -1 4.000 0 0 -1 1 1 3
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+3510 4050 3870 3690 3870
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+3960 4770 3960
+4 0 1 0 11 51 -1 20 0.000 0 0 7 0 0 5
+4050 3060 4050 3060 3600 3780 3600 3780 4050
+1 0 1 0 31 50 -1 -1 4.000 0 0 -1 1 1 3
+0 1.00 60.00 120.00
+0 1.00 60.00 120.00
+3510 3960 3780 3780 3780
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+4050 4770 4050
+2 2 1 0 7 50 -1 -1 3.000 0 0 -1 0 0 5
+2880 2790 2880 2790 4320 5580 4320 5580 2880
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+6750 4770 6750 4770 7200 5490 7200 5490 6750
 0 1 50 -1 -1 12 0.0000 4 135 360 1710 2205 Core\001
 0 1 50 -1 -1 12 0.0000 4 180 1575 5760 2520 Out Of Order Engine\001
 …
 1 0 50 -1 -1 12 0.0000 4 105 570 5130 7065 context\001
 1 0 50 -1 -1 12 0.0000 4 180 675 4230 7200 predictor\001
 1 0 50 -1 -1 12 6.2832 4 135 555 6930 7245 commit\001
 1 0 50 -1 -1 12 6.2832 4 90 555 6210 6525 rename\001
+1 0 50 -1 -1 12 0.0000 4 135 555 6930 7245 commit\001
+1 0 50 -1 -1 12 0.0000 4 90 555 6210 6525 rename\001

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Schema/MORPHEO_micro_architecture-overview.fig

-              r81
+              r88
 #FIG 3.2  Produced by xfig version 3.2.5
+#FIG 3.2
 Landscape
 Center
 …
 -2
 2
-4770 3240 5490 3690
-4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
-3690 4770 3690 4770 3240 5490 3240 5490 3690
-1 0 50 -1 -1 12 0.0000 4 120 645 5130 3420 context\001
-1 0 50 -1 -1 12 0.0000 4 120 420 5130 3600 state\001
--6
 8370 3690 9090 4140
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 4140 8370 4140 8370 3690 9090 3690 9090 4140
 1 0 50 -1 -1 12 0.0000 4 150 390 8730 3960 read\001
+1 0 50 -1 -1 12 0.0000 4 135 330 8730 3960 read\001
 -6
 11250 3690 11970 4140
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 4140 11250 4140 11250 3690 11970 3690 11970 4140
 1 0 50 -1 -1 12 0.0000 4 150 450 11610 3960 write\001
+1 0 50 -1 -1 12 0.0000 4 135 390 11610 3960 write\001
 -6
 9810 2475 10530 2925
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 2925 9810 2925 9810 2475 10530 2475 10530 2925
 1 0 50 -1 -1 12 0.0000 4 165 345 10170 2835 port\001
 1 0 50 -1 -1 12 0.0000 4 150 630 10170 2655 dcache\001
+1 0 50 -1 -1 12 0.0000 4 150 300 10170 2835 port\001
+1 0 50 -1 -1 12 0.0000 4 135 540 10170 2655 dcache\001
 -6
 3825 3060 4635 3510
 4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 3510 3870 3510 3870 3060 4590 3060 4590 3510
+1 0 50 -1 -1 12 0.0000 4 195 780 4230 3330 predictor\001
+-6
+2970 3690 3690 4140
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4140 2970 4140 2970 3690 3690 3690 3690 4140
+1 0 50 -1 -1 12 0.0000 4 150 435 3330 3960 fetch\001
+1 0 50 -1 -1 12 0.0000 4 180 675 4230 3330 predictor\001
 -6
 1890 3690 2610 4140
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 4140 1890 4140 1890 3690 2610 3690 2610 4140
 1 0 50 -1 -1 12 0.0000 4 165 345 2250 4050 port\001
 1 0 50 -1 -1 12 0.0000 4 150 570 2250 3870 icache\001
+1 0 50 -1 -1 12 0.0000 4 150 300 2250 4050 port\001
+1 0 50 -1 -1 12 0.0000 4 135 495 2250 3870 icache\001
 -6
 1800 4590 5265 5355
 …
 4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 5310 1800 5310 1800 5130 2160 5130 2160 5310
 0 0 50 -1 -1 12 0.0000 4 195 660 2340 4770 Groupe\001
 0 0 50 -1 -1 12 0.0000 4 195 2610 2340 5310 Une occurence dans le groupe\001
 0 0 50 -1 -1 12 0.0000 4 195 3120 2340 5040 Plusieurs occurences dans le groupe\001
+0 0 50 -1 -1 12 0.0000 4 180 555 2340 4770 Groupe\001
+0 0 50 -1 -1 12 0.0000 4 180 2280 2340 5310 Une occurence dans le groupe\001
+0 0 50 -1 -1 12 0.0000 4 180 2760 2340 5040 Plusieurs occurences dans le groupe\001
 -6
 6570 3015 7290 3465
 4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
 3465 6570 3465 6570 3015 7290 3015 7290 3465
+1 0 50 -1 -1 12 0.0000 4 150 645 6930 3285 commit\001
+-6
+4770 3690 5490 4140
+4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+4140 4770 4140 4770 3690 5490 3690 5490 4140
+1 0 50 -1 0 12 0.0000 4 150 525 5130 3960 decod\001
+1 0 50 -1 -1 12 0.0000 4 135 555 6930 3285 commit\001
 -6
 1 0 1 0 7 50 -1 -1 4.000 0 0 -1 1 0 4
 …
 4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 3870 9810 3870 9810 3420 10530 3420 10530 3870
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4140 2970 4140 2970 3690 3690 3690 3690 4140
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
+4140 4770 4140 4770 3690 5490 3690 5490 4140
 4 0 1 0 31 50 -1 20 4.000 0 0 7 0 0 5
+3690 4770 3690 4770 3240 5490 3240 5490 3690
+4 0 1 0 11 50 -1 20 4.000 0 0 7 0 0 5
 4140 5850 4140 5850 3690 6570 3690 6570 4140
+1 0 50 -1 -1 12 0.0000 4 195 660 10170 4905 register\001
+1 0 50 -1 -1 12 1.5708 4 150 510 10935 3915 select\001
+1 0 50 -1 -1 12 1.5708 4 150 510 9495 3915 select\001
+0 1 50 -1 -1 12 0.0000 4 150 435 1710 2205 Core\001
+0 1 50 -1 -1 12 0.0000 4 150 855 2790 2790 Front End\001
+0 1 50 -1 -1 12 0.0000 4 195 1365 8190 3015 Execution Loop\001
+0 1 50 -1 -1 12 0.0000 4 195 1770 5760 2520 Out Of Order Engine\001
+1 0 50 -1 -1 12 1.5708 4 150 510 7875 3600 select\001
+1 0 50 -1 -1 12 0.0000 4 120 690 10170 4230 execute\001
+1 0 50 -1 -1 12 0.0000 4 150 720 10170 3690 memory\001
+1 0 50 -1 0 12 0.0000 4 105 660 6210 3960 rename\001
+1 0 50 -1 -1 12 0.0000 4 180 585 10170 4905 register\001
+1 0 50 -1 -1 12 1.5708 4 135 465 10935 3915 select\001
+1 0 50 -1 -1 12 1.5708 4 135 465 9495 3915 select\001
+0 1 50 -1 -1 12 0.0000 4 135 360 1710 2205 Core\001
+0 1 50 -1 -1 12 0.0000 4 135 750 2790 2790 Front End\001
+0 1 50 -1 -1 12 0.0000 4 180 1185 8190 3015 Execution Loop\001
+0 1 50 -1 -1 12 0.0000 4 180 1575 5760 2520 Out Of Order Engine\001
+1 0 50 -1 -1 12 1.5708 4 135 465 7875 3600 select\001
+1 0 50 -1 -1 12 0.0000 4 105 600 10170 4230 execute\001
+1 0 50 -1 -1 12 0.0000 4 135 600 10170 3690 memory\001
+1 0 50 -1 0 12 0.0000 4 90 555 6210 3960 rename\001
+1 0 50 -1 -1 12 0.0000 4 135 390 3330 3960 fetch\001
+1 0 50 -1 0 12 0.0000 4 135 450 5130 3960 decod\001
+1 0 50 -1 -1 12 0.0000 4 105 570 5130 3420 context\001
+1 0 50 -1 -1 12 0.0000 4 105 390 5130 3600 state\001

trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Schema/VHDL_methodologie.fig

-              r81
+              r88
 -2
 2
+-1425 -600 2850 4050
+900 -1500 2100 -750
+900 -1500 2100 -1200
+4 0 1 0 30 51 -1 20 0.000 0 0 7 0 0 5
+-1200 900 -1200 900 -1500 2100 -1500 2100 -1200
+1 0 50 -1 2 8 0.0000 0 105 315 1500 -1350 D\351but\001
+-6
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+-1200 1500 -750
+-6
 1 0 1 0 6 51 -1 20 0.000 1 0.0000 -750 750 600 225 -750 750 -150 525
+1 0 1 0 6 51 -1 20 0.000 1 0.0000 1500 3075 600 225 1500 3075 2100 2850
+1 0 1 0 6 51 -1 20 0.000 1 0.0000 1500 375 600 225 1500 375 2100 150
 1 0 1 0 6 51 -1 20 0.000 1 0.0000 1500 2175 600 225 1500 2175 2100 1950
-1 0 1 0 6 51 -1 20 0.000 1 0.0000 1500 3075 600 225 1500 3075 2100 2850
 1 0 1 0 7 50 -1 20 0.000 0 0 -1 1 0 2
 0 1.00 60.00 120.00
+600 2250 1050
+1 0 1 0 7 50 -1 20 0.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+600 1050 1050
+825 2250 1050
 1 0 1 0 7 50 -1 20 0.000 0 0 -1 1 0 2
 0 1.00 60.00 120.00
 …
 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 4
 0 1.00 60.00 120.00
          -750 525 -750 -75 1200 -75 1200 150
+         -750 525 -750 -975 1200 -975 1200 -750
 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 3
 0 1.00 60.00 120.00
 3075 -750 3075 -750 975
-1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
-0 1.00 60.00 120.00
--300 1500 150
-4 0 1 0 30 51 -1 20 0.000 0 0 7 0 0 5
--300 900 -300 900 -600 2100 -600 2100 -300
 4 0 1 0 30 51 -1 20 0.000 0 0 7 0 0 5
 4050 900 4050 900 3750 2100 3750 2100 4050
-4 0 1 0 11 51 -1 20 0.000 0 0 7 0 0 5
-600 900 600 900 150 2100 150 2100 600
 4 0 1 0 11 51 -1 20 0.000 0 0 7 0 0 5
 1500 150 1500 150 1050 1350 1050 1350 1500
 4 0 1 0 11 51 -1 20 0.000 0 0 7 0 0 5
 1500 1650 1500 1650 1050 2850 1050 2850 1500
+1 0 50 -1 2 8 0.0000 0 75 240 1500 2175 Test\001
+1 0 50 -1 2 8 0.0000 0 90 990 2250 1275 TestBench VHDL\001
+1 0 50 -1 2 8 0.0000 0 105 1005 750 1275 G\351n\351rateur VHDL\001
+1 0 50 -1 2 8 0.0000 0 105 465 1500 375 SystemC\001
+1 0 50 -1 2 8 0.0000 0 90 1050 -750 675 Modification locale\001
+1 0 50 -1 2 8 0.0000 0 105 1035 -750 825 (micro architecture)\001
+1 0 50 -1 2 8 0.0000 0 105 315 1500 -450 D\351but\001
+1 0 50 -1 2 8 0.0000 0 135 810 1500 3075 Synth\350tisable ?\001
+1 0 50 -1 2 8 0.0000 0 90 195 1500 3900 Fin\001
+-6
+1 0 1 0 7 50 -1 20 0.000 0 0 7 1 0 2
+0 1.00 60.00 120.00
+825 1050 1050
+1 0 1 0 7 50 -1 20 0.000 0 0 -1 0 0 2
+600 1500 825
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 5
+0 1.00 60.00 120.00
+375 2250 375 2250 -900 1800 -900 1800 -750
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
+0 1.00 60.00 120.00
+-300 1500 150
+4 0 1 0 11 51 -1 20 0.000 0 0 7 0 0 5
+-300 900 -300 900 -750 2100 -750 2100 -300
 0 0 51 -1 0 8 0.0000 0 75 120 1575 3450 ok\001
 0 0 51 -1 0 8 0.0000 0 75 315 -75 675 locale\001
 0 0 51 -1 0 8 0.0000 0 90 375 -675 450 globale\001
 2 0 51 -1 0 8 0.0000 0 75 120 900 3000 ko\001
+2 0 51 -1 0 8 0.0000 0 75 120 900 2100 ko\001
+1 0 50 -1 2 8 0.0000 0 90 1050 -750 675 Modification locale\001
+1 0 50 -1 2 8 0.0000 0 105 1035 -750 825 (micro architecture)\001
+1 0 50 -1 2 8 0.0000 0 135 810 1500 3075 Synth\350tisable ?\001
+1 0 50 -1 2 8 0.0000 0 90 195 1500 3900 Fin\001
+0 0 51 -1 0 8 0.0000 0 75 120 1575 750 ok\001
+1 0 50 -1 2 8 0.0000 0 75 240 1500 375 Test\001
+0 0 51 -1 0 8 0.0000 0 75 120 2025 225 ko\001
 0 0 51 -1 0 8 0.0000 0 75 120 1575 2550 ok\001
+1 0 50 -1 2 8 0.0000 0 75 240 1500 2175 Test\001
+2 0 51 -1 0 8 0.0000 0 75 120 825 2025 ko\001
+1 0 50 -1 2 8 0.0000 0 75 375 750 1425 VHDL\001
+1 0 50 -1 2 8 0.0000 0 75 375 2250 1425 VHDL\001
+1 0 50 -1 2 8 0.0000 0 90 615 2250 1200 TestBench \001
+1 0 50 -1 2 8 0.0000 0 105 465 1500 -375 SystemC\001
+1 0 50 -1 2 8 0.0000 0 105 450 750 1200 Mod\350le \001
+1 0 50 -1 2 8 0.0000 0 105 450 1500 -600 Mod\350le \001

trunk/IPs/systemC/processor/Morpheo/Makefile

-              r81
+              r88
+include $(MORPHEO_TOPLEVEL)/Makefile.tools
+#
+# $Id$
+#
+# [ Description ]
+#
+# Makefile
+#
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+#-----[ Variables ]----------------------------------------------------
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
 #-----[ Directory ]----------------------------------------------------
 DIR_LIB                 = Library
 DIR_DOC                 = Documentation/Source
+DIR_DOC                 = ./Documentation/Source
+DIR_LOCALE              = ./locale
+#-----[ Options ]------------------------------------------------------
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+#-----[ Rules ]--------------------------------------------------------
+#----------------------------------------------------------------------
+#----------------------------------------------------------------------
+.PHONY                  : all help lib translate clean clean_all
+PREFIXE_PATH            = "."
+SUFFIXE_PATH            = ".txt"
+all                     : doc translate lib
-#-----[ Rules ]--------------------------------------------------------
-.PHONY                  : all help
-all                     : help
-#~~~~~[ doc ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 doc                     :
                         @\
+                        $(ECHO) "";\
+                        $(ECHO) "=====[ doc ]=====================================";\
+                        $(ECHO) "";\
+                        $(MAKE) -C $(DIR_DOC) view;
+                        $(MAKE) -C $(DIR_DOC) doc;
+#~~~~~[ path ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+path                    :
+lib                     : Morpheo_library
+translate               :
                         @\
+                        $(ECHO) "";\
+                        $(ECHO) "=====[ path ]====================================";\
+                        $(ECHO) "";\
+                        $(ECHO) -n "+ ";\
+                        $(BASENAME) $(PWD);\
+                        $(ECHO) "| <Top Level>";\
+                        $(ECHO) "|";\
+                        $(MAKE) path_rec TAB="|    " DIR_PATH=.;
+                        for i in $(DIR_LOCALE)/*/*/*.po; do             \
+                                dir=$$($(DIRNAME) $$i);                 \
+                                file=$$($(BASENAME) $$i .po);           \
+                                $(ECHO) "Translate          : $$i";     \
+                                $(MSGFMT) $$i -o $$dir/$$file.mo;       \
+                        done
+path_rec                :
+                        @\
+                        for files in `$(LS) $(DIR_PATH)`; do                                                            \
+                                if $(TEST) -d $(DIR_PATH)/$$files;                                                      \
+                                then                                                                                    \
+                                        $(ECHO) "$(TAB)+ $$files";                                                      \
+                                                                                                                        \
+                                        if test -f $(DIR_PATH)/$(PREFIXE_PATH)`$(BASENAME) $$files`$(SUFFIXE_PATH);     \
+                                        then                                                                            \
+                                                $(ECHO) "$(TAB)| <\c";                                                  \
+                                                $(CAT) $(DIR_PATH)/$(PREFIXE_PATH)`$(BASENAME) $$files`$(SUFFIXE_PATH); \
+                                                $(ECHO) ">";                                                            \
+                                        else                                                                            \
+                                                $(ECHO) "$(TAB)| <No description>";                                     \
+                                        fi;                                                                             \
+                                        $(ECHO) "$(TAB)|";                                                              \
+                                                                                                                        \
+                                        $(MAKE) path_rec TAB="$(TAB)|    " DIR_PATH=$(DIR_PATH)/$$files;                \
+                                fi;                                                                                     \
+                        done;
+#~~~~~[ Lib ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+lib                     :
+                        @\
+                        $(ECHO) "";\
+                        $(ECHO) "=====[ lib ]=====================================";\
+                        $(ECHO) "";\
+                        $(ECHO) " Function unimplemented";\
+                        $(ECHO) "";
+#                       @$(ECHO) " The library is generate into the directory : $(PWD)/$(DIR_LIB)"
+#~~~~~[ Maintenance ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#~~~~~[ Clean ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 clean                   :
                         @\
+                        $(ECHO) "";\
+                        $(ECHO) "=====[ clean ]===================================";\
+                        $(ECHO) "";\
+                        $(ECHO) "Delete     temporary files              "$(PWD);\
+                        $(RM) *~;
+#                       @$(MAKE) clean_rec DIR_CLEAN=.
+                        $(RM) *~;\
+                        $(MAKE) -C $(DIR_DOC) clean;
+#Clean recursive
+#clean_rec              :
+#                       @$(ECHO) "Delete     temporary files in directory $(DIR_CLEAN)"
+#                       @$(RM) -f $(DIR_CLEAN)/*~
+#                       @                                                                               \
+#                       if $(TEST) -f $(DIR_CLEAN)/Makefile -a "$(DIR_CLEAN)" != ".";                   \
+#                       then                                                                            \
+#                               ($(CD) $(DIR_CLEAN); $(MAKE) clean;)                                    \
+#                       else                                                                            \
+#                               for files in `$(LS) $(DIR_CLEAN)`; do                                   \
+#                                       if $(TEST) -d $(DIR_CLEAN)/$$files;                             \
+#                                       then                                                            \
+#                                               $(MAKE) clean_rec DIR_CLEAN=$(DIR_CLEAN)/$$files;       \
+#                                       fi;                                                             \
+#                               done;                                                                   \
+#                       fi;
+clean_all               :
+                        @\
+                        $(RM) *~ $(DIR_LOCALE)/*/*/*.mo;\
+                        $(MAKE) -C $(DIR_DOC) clean_all;\
+                        $(MAKE)  Morpheo_library_clean
 #~~~~~[ Help ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 …
                         $(ECHO) " * all              cf rule \"help\"";\
                         $(ECHO) " * clean            Delete temporary files";\
+                        $(ECHO) " * clean_all        Delete all generated files";\
                         $(ECHO) " * doc              View documentation files";\
+                        $(ECHO) " * help             Print this message";\
                         $(ECHO) " * lib              Generate the library to include";\
+                        $(ECHO) " * help             Print this message";\
+                        $(ECHO) " * path             Print a little description of each directory";\
+                        $(ECHO) " * translate        Generate the traduction";\
                         $(ECHO) "";
+include Makefile.deps

trunk/IPs/systemC/processor/Morpheo/Script/SelfTest.sh

-              r85
+              r88
 declare    test_ok="Test OK";
 declare    tmp="${MORPHEO_HOME}/tmp/SelfTest";
 declare    path="${MORPHEO_TOPLEVEL}/IPs/systemC/processor/Morpheo/Behavioural";
+declare    path="${MORPHEO_TOPLEVEL}/IPs/systemC/processor/Morpheo/";
 declare -a directory=(
+    ""
+    "Custom"
+    "Generic/Counter"
+    "Generic/Queue_Control"
+    "Generic/Queue"
+    "Generic/RegisterFile/RegisterFile_Monolithic"
+    "Generic/RegisterFile/RegisterFile_Multi_Banked"
+    "Generic/RegisterFile"
+    "Generic/Select/Select_Priority_Fixed"
+    "Generic/Select"
+    "Generic/Shifter"
+    "Generic/Sort"
+    "Generic/Victim/Victim_Pseudo_LRU"
+    "Generic/Victim"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit"
+    "Core/Multi_Execute_loop/Execute_loop/Network"
+    "Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue"
+    "Core/Multi_Execute_loop/Execute_loop/Register_unit"
+#   "Core/Multi_Execute_loop/Execute_loop"
+#   "Core/Multi_Execute_loop"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_queue"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select"
+    "Core/Multi_OOO_Engine/OOO_Engine/Rename_unit"
+    "Core/Multi_OOO_Engine/OOO_Engine"
+    "Core/Multi_OOO_Engine"
+    "Common"
+    "Behavioural"
+    "Behavioural/Configuration"
+    "Behavioural/Custom"
+    "Behavioural/Generic/Counter"
+    "Behavioural/Generic/Priority"
+    "Behavioural/Generic/Queue_Control"
+    "Behavioural/Generic/Queue"
+    "Behavioural/Generic/RegisterFile/RegisterFile_Monolithic"
+    "Behavioural/Generic/RegisterFile/RegisterFile_Multi_Banked"
+    "Behavioural/Generic/RegisterFile"
+    "Behavioural/Generic/Select/Select_Priority_Fixed"
+    "Behavioural/Generic/Select"
+    "Behavioural/Generic/Shifter"
+    "Behavioural/Generic/Sort"
+    "Behavioural/Generic/Victim/Victim_Pseudo_LRU"
+    "Behavioural/Generic/Victim"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Execute_loop_Glue"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Load_store_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Execute_queue"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit/Write_queue"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit/Write_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Write_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Execution_unit_to_Write_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network/Read_unit_to_Execution_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Network"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit"
+    "Behavioural/Core/Multi_Execute_loop/Execute_loop"
+    "Behavioural/Core/Multi_Execute_loop"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/OOO_Engine_Glue"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Reexecute_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Load_Store_pointer_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Dependency_checking_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Free_List_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_Address_Translation_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Register_translation_unit_Glue"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_unit_Glue"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Rename_select"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Special_Register_unit"
+    "Behavioural/Core/Multi_OOO_Engine/OOO_Engine"
+    "Behavioural/Core/Multi_OOO_Engine"
+    "Core/Multi_Front_end/Front_end/Context_State"
+    "Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction"
+    "Core/Multi_Front_end/Front_end/Decod_unit/Decod"
+    "Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue"
+    "Core/Multi_Front_end/Front_end/Decod_unit"
+    "Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management"
+    "Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue"
+    "Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue"
+    "Core/Multi_Front_end/Front_end/Ifetch_unit"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Direction"
+#   "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Meta_Predictor_Glue"
+#   "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor/Two_Level_Branch_Predictor_Glue"
+#   "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor/Branch_History_Table"
+#   "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor/Pattern_History_Table"
+#   "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor"
+#   "Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack"
+    "Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table"
+    "Core/Multi_Front_end/Front_end/Prediction_unit"
+    "Core/Multi_Front_end/Front_end"
+    "Core/Multi_Front_end"
+    "Behavioural/Core/Multi_Front_end/Front_end/Context_State"
+    "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction"
+    "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod"
+    "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod_queue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit"
+    "Behavioural/Core/Multi_Front_end/Front_end/Front_end_Glue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Address_management"
+    "Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_queue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit/Ifetch_unit_Glue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Ifetch_unit"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Glue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer/Branch_Target_Buffer_Register"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Branch_Target_Buffer"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Direction_Glue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction"
+#   "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Meta_Predictor_Glue"
+#   "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor/Two_Level_Branch_Predictor_Glue"
+#   "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor/Branch_History_Table"
+#   "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor/Pattern_History_Table"
+#   "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor/Two_Level_Branch_Predictor"
+#   "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Direction/Meta_Predictor"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Prediction_unit_Glue"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Update_Prediction_Table"
+    "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit"
+    "Behavioural/Core/Multi_Front_end/Front_end"
+    "Behavioural/Core/Multi_Front_end"
+    "Behavioural/Core/Icache_Access"
+    "Behavioural/Core/Dcache_Access"
+    "Behavioural/Core/Core_Glue"
+    "Behavioural/Core"
+    "TopLevel"
     );
 …
     if test ! -d ${tmp}; then
         mkdir ${tmp};
+        mkdir -p ${tmp};
     fi;
 …
                 cd ${path}/${i};
+                make clean;
+                dir="SelfTest";
+                if test -d ${dir}; then
+                    cd ${dir};
+                if test -f "Makefile"; then
                     make clean;
+                else
+                    echo "${component} have not SelfTest directory.";
+                fi;
+                cd ${pwd};
+                    dir="SelfTest";
+                    if test -d ${dir}; then
+                        cd ${dir};
+                        make clean;
+                    else
+                        echo "${component} have not SelfTest directory.";
+                    fi;
+                    cd ${pwd};
+                fi;
             done;
             ;;

trunk/IPs/systemC/processor/Morpheo/Script/version.sh

-              r85
+              r88
 file_sed_src="${MORPHEO_TOPLEVEL}/IPs/systemC/processor/Morpheo/Behavioural/include/Version.h.sed";
 file_sed_dest="${MORPHEO_TOPLEVEL}/IPs/systemC/processor/Morpheo/Behavioural/include/Version.h";
+file_sed_script="/tmp/file_sed_script";
 #-----[ usage ]---------------------------------------------
 …
             # +1 because is the next revision
             revision=$(($(export LC_ALL=C; svnversion  | tr -d [:alpha:] | cut -d : -f 2) + 1));
+            cat ${file_sed_src} |sed s/"@REVISION"/"${revision}"/ &> ${file_sed_dest};
+            date_day=$(date +%d);
+            date_month=$(date +%m);
+            date_year=$(date +%Y);
+            echo "s/\"@REVISION\"/\"${revision}\"/"     >  ${file_sed_script};
+            echo "s/\"@DATE_DAY\"/\"${date_day}\"/"     >> ${file_sed_script};
+            echo "s/\"@DATE_MONTH\"/\"${date_month}\"/" >> ${file_sed_script};
+            echo "s/\"@DATE_YEAR\"/\"${date_year}\"/"   >> ${file_sed_script};
+            cat ${file_sed_src} |sed -f ${file_sed_script} &> ${file_sed_dest};
+            rm ${file_sed_script};
             svn commit;

trunk/IPs/systemC/processor/Morpheo/locale/fr/LC_MESSAGES/morpheo.po

r82	r88
	1	msgid "Read file \"%s\"."
	2	msgstr "Lecture du fichier \"%s\"."

Context Navigation

Legend: