Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Commit_unit.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Commit_unit.h	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Commit_unit.h	(revision 123)
@@ -85,4 +85,5 @@
   public    : SC_IN (Toperation_t       ) ***  in_INSERT_OPERATION                 ;//[nb_rename_unit][nb_inst_insert]
   public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_NO_EXECUTE                ;//[nb_rename_unit][nb_inst_insert]
+  public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_LAST_EVENT                ;//[nb_rename_unit][nb_inst_insert]
   public    : SC_IN (Tcontrol_t         ) ***  in_INSERT_IS_DELAY_SLOT             ;//[nb_rename_unit][nb_inst_insert]
 #ifdef DEBUG
@@ -143,5 +144,5 @@
   public    : SC_IN (Tcontrol_t         ) ***  in_RETIRE_EVENT_ACK                 ;//[nb_front_end][nb_context]
   public    : SC_OUT(Tevent_state_t     ) *** out_RETIRE_EVENT_STATE               ;//[nb_front_end][nb_context]
-  public    : SC_OUT(Tcontrol_t         ) *** out_RETIRE_EVENT_FLUSH               ;//[nb_front_end][nb_context]
+//public    : SC_OUT(Tcontrol_t         ) *** out_RETIRE_EVENT_FLUSH               ;//[nb_front_end][nb_context]
   public    : SC_OUT(Tcontrol_t         ) *** out_RETIRE_EVENT_STOP                ;//[nb_front_end][nb_context]
 										   
@@ -225,4 +226,9 @@
   public    : SC_OUT(Tcontrol_t         ) *** out_SPR_WRITE_SR_OV                  ;//[nb_front_end][nb_context]
 
+    // ~~~~~[ interface : "info" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#ifdef DEBUG_TEST
+  public    : SC_OUT(bool               )   * out_INFO_ROB_EMPTY                   ;
+#endif
+
     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    	   
   private   : generic::priority::Priority   * _priority_insert                     ;
@@ -243,12 +249,15 @@
   private   : Tcommit_event_state_t        ** reg_EVENT_STATE                      ;//[nb_front_end][nb_context]
 //private   : bool                         ** reg_EVENT_FLUSH                      ;//[nb_front_end][nb_context]
-  private   : bool                         ** reg_EVENT_STOP                       ;//[nb_front_end][nb_context]
+//private   : bool                         ** reg_EVENT_STOP                       ;//[nb_front_end][nb_context]
   private   : uint32_t                     ** reg_EVENT_NUM_BANK                   ;//[nb_front_end][nb_context]
   private   : uint32_t                     ** reg_EVENT_NUM_PTR                    ;//[nb_front_end][nb_context]
-  private   : bool                         ** reg_EVENT_CAN_RESTART                ;//[nb_front_end][nb_context]
+//private   : bool                         ** reg_EVENT_CAN_RESTART                ;//[nb_front_end][nb_context]
   private   : uint32_t                     ** reg_EVENT_PACKET                     ;//[nb_front_end][nb_context]
   private   : bool                         ** reg_EVENT_LAST                       ;//[nb_front_end][nb_context]
   private   : uint32_t                     ** reg_EVENT_LAST_NUM_BANK              ;//[nb_front_end][nb_context]
   private   : uint32_t                     ** reg_EVENT_LAST_NUM_PTR               ;//[nb_front_end][nb_context]
+
+  private   : bool                         ** reg_EVENT_NEXT_STOP                  ;//[nb_front_end][nb_context]
+  private   : uint32_t                     ** reg_EVENT_NEXT_PACKET                ;//[nb_front_end][nb_context]
 
 //private   : Taddress_t                   ** reg_PC_PREVIOUS                      ;//[nb_front_end][nb_context]
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Types.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Types.h	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/include/Types.h	(revision 123)
@@ -62,12 +62,14 @@
   typedef enum
     {
-      COMMIT_EVENT_STATE_NO_EVENT  ,
-      COMMIT_EVENT_STATE_EVENT     ,
-      COMMIT_EVENT_STATE_WAIT_DECOD,
-      COMMIT_EVENT_STATE_WAIT_END  ,
+      COMMIT_EVENT_STATE_NO_EVENT     ,
+      COMMIT_EVENT_STATE_NOT_YET_EVENT,
+      COMMIT_EVENT_STATE_EVENT        ,
+//    COMMIT_EVENT_STATE_WAIT_DECOD   ,
+      COMMIT_EVENT_STATE_WAIT_END     ,
       COMMIT_EVENT_STATE_END     
     } Tcommit_event_state_t;
 
-#define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_DECOD)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_END)?EVENT_STATE_END:EVENT_STATE_NO_EVENT))))
+#define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_END)?EVENT_STATE_END:EVENT_STATE_NO_EVENT)))
+// #define commit_event_state_to_event_state(x) ((x==COMMIT_EVENT_STATE_EVENT)?EVENT_STATE_EVENT:((x==COMMIT_EVENT_STATE_WAIT_DECOD)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_WAIT_END)?EVENT_STATE_WAITEND:((x==COMMIT_EVENT_STATE_END)?EVENT_STATE_END:EVENT_STATE_NO_EVENT))))
 
 
@@ -147,4 +149,5 @@
       case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_OK_WAIT_END          : return "ROB_STORE_OK_WAIT_END"           ; break;
       case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_KO_WAIT_END          : return "ROB_STORE_KO_WAIT_END"           ; break;
+      case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_STORE_EVENT                : return "ROB_STORE_EVENT"                 ; break;
       case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_OTHER_WAIT_END             : return "ROB_OTHER_WAIT_END"              ; break;
       case morpheo::behavioural::core::multi_ooo_engine::ooo_engine::commit_unit::ROB_EVENT_WAIT_END             : return "ROB_EVENT_WAIT_END"              ; break;
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit.cpp	(revision 123)
@@ -40,9 +40,9 @@
     usage_environment(_usage);
 
-#if DEBUG_Commit_unit == true
-    log_printf(TRACE,Commit_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
-
-    std::cout << *param << std::endl;
-#endif
+// #if DEBUG_Commit_unit == true
+//     log_printf(TRACE,Commit_unit,FUNCTION,_("<%s> Parameters"),_name.c_str());
+
+//     std::cout << *param << std::endl;
+// #endif
 
     log_printf(INFO,Commit_unit,FUNCTION,_("<%s> Allocation"),_name.c_str());
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_allocation.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_allocation.cpp	(revision 123)
@@ -71,4 +71,5 @@
       _ALLOC2_SIGNAL_IN ( in_INSERT_OPERATION               ,"operation"            ,Toperation_t      ,_param->_size_operation             ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
       _ALLOC2_SIGNAL_IN ( in_INSERT_NO_EXECUTE              ,"no_execute"           ,Tcontrol_t        ,1                                   ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
+      _ALLOC2_SIGNAL_IN ( in_INSERT_LAST_EVENT              ,"last_event"           ,Tcontrol_t        ,1                                   ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
       _ALLOC2_SIGNAL_IN ( in_INSERT_IS_DELAY_SLOT           ,"is_delay_slot"        ,Tcontrol_t        ,1                                   ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1]);
 #ifdef DEBUG
@@ -141,5 +142,5 @@
       _ALLOC2_VALACK_IN ( in_RETIRE_EVENT_ACK               ,ACK,_param->_nb_front_end,_param->_nb_context[it1]);
       _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_STATE             ,"state"                ,Tevent_state_t    ,_param->_size_event_state           ,_param->_nb_front_end,_param->_nb_context[it1]);
-      _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_FLUSH             ,"flush"                ,Tcontrol_t        ,1                                   ,_param->_nb_front_end,_param->_nb_context[it1]);
+//    _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_FLUSH             ,"flush"                ,Tcontrol_t        ,1                                   ,_param->_nb_front_end,_param->_nb_context[it1]);
       _ALLOC2_SIGNAL_OUT(out_RETIRE_EVENT_STOP              ,"stop"                 ,Tcontrol_t        ,1                                   ,_param->_nb_front_end,_param->_nb_context[it1]);
 
@@ -282,4 +283,12 @@
     }
 
+#ifdef DEBUG_TEST
+    {
+      ALLOC0_INTERFACE_BEGIN("info",OUT,EAST,_("Information."));
+      ALLOC0_SIGNAL_OUT(out_INFO_ROB_EMPTY                   ,"rob_empty"   ,bool               ,1);
+      ALLOC0_INTERFACE_END();
+    }
+#endif
+
     if (usage_is_set(_usage,USE_SYSTEMC))
       {
@@ -318,12 +327,15 @@
     ALLOC2(reg_EVENT_STATE          ,Tcommit_event_state_t,_param->_nb_front_end,_param->_nb_context [it1]);
 //  ALLOC2(reg_EVENT_FLUSH          ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
-    ALLOC2(reg_EVENT_STOP           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
+//  ALLOC2(reg_EVENT_STOP           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
     ALLOC2(reg_EVENT_NUM_BANK       ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
     ALLOC2(reg_EVENT_NUM_PTR        ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
-    ALLOC2(reg_EVENT_CAN_RESTART    ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
+//  ALLOC2(reg_EVENT_CAN_RESTART    ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
     ALLOC2(reg_EVENT_PACKET         ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
     ALLOC2(reg_EVENT_LAST           ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
     ALLOC2(reg_EVENT_LAST_NUM_BANK  ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
     ALLOC2(reg_EVENT_LAST_NUM_PTR   ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
+
+    ALLOC2(reg_EVENT_NEXT_STOP      ,bool                 ,_param->_nb_front_end,_param->_nb_context [it1]);
+    ALLOC2(reg_EVENT_NEXT_PACKET    ,uint32_t             ,_param->_nb_front_end,_param->_nb_context [it1]);
                                                           
 //  ALLOC2(reg_PC_PREVIOUS          ,Taddress_t           ,_param->_nb_front_end,_param->_nb_context [it1]);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_deallocation.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_deallocation.cpp	(revision 123)
@@ -38,4 +38,5 @@
         DELETE2_SIGNAL( in_INSERT_OPERATION               ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],_param->_size_operation             );
         DELETE2_SIGNAL( in_INSERT_NO_EXECUTE              ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],1                                   );
+        DELETE2_SIGNAL( in_INSERT_LAST_EVENT              ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],1                                   );
         DELETE2_SIGNAL( in_INSERT_IS_DELAY_SLOT           ,_param->_nb_rename_unit,_param->_nb_inst_insert[it1],1                                   );
 #ifdef DEBUG
@@ -94,5 +95,5 @@
         DELETE2_SIGNAL( in_RETIRE_EVENT_ACK               ,_param->_nb_front_end,_param->_nb_context[it1],1);
         DELETE2_SIGNAL(out_RETIRE_EVENT_STATE             ,_param->_nb_front_end,_param->_nb_context[it1],_param->_size_event_state);
-        DELETE2_SIGNAL(out_RETIRE_EVENT_FLUSH             ,_param->_nb_front_end,_param->_nb_context[it1],1);
+//      DELETE2_SIGNAL(out_RETIRE_EVENT_FLUSH             ,_param->_nb_front_end,_param->_nb_context[it1],1);
         DELETE2_SIGNAL(out_RETIRE_EVENT_STOP              ,_param->_nb_front_end,_param->_nb_context[it1],1);
 
@@ -167,4 +168,6 @@
 	DELETE2_SIGNAL(out_SPR_WRITE_SR_OV                ,_param->_nb_front_end, _param->_nb_context[it1],1);
 
+        DELETE0_SIGNAL(out_INFO_ROB_EMPTY                 ,1);
+
         // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	   
         DELETE1(internal_BANK_INSERT_VAL             ,_param->_nb_bank);
@@ -207,12 +210,15 @@
         DELETE2(reg_EVENT_STATE          ,_param->_nb_front_end,_param->_nb_context [it1]);
 //      DELETE2(reg_EVENT_FLUSH          ,_param->_nb_front_end,_param->_nb_context [it1]);
-        DELETE2(reg_EVENT_STOP           ,_param->_nb_front_end,_param->_nb_context [it1]);
+//      DELETE2(reg_EVENT_STOP           ,_param->_nb_front_end,_param->_nb_context [it1]);
         DELETE2(reg_EVENT_NUM_BANK       ,_param->_nb_front_end,_param->_nb_context [it1]);
         DELETE2(reg_EVENT_NUM_PTR        ,_param->_nb_front_end,_param->_nb_context [it1]);
-        DELETE2(reg_EVENT_CAN_RESTART    ,_param->_nb_front_end,_param->_nb_context [it1]);
+//         DELETE2(reg_EVENT_CAN_RESTART    ,_param->_nb_front_end,_param->_nb_context [it1]);
         DELETE2(reg_EVENT_PACKET         ,_param->_nb_front_end,_param->_nb_context [it1]);
         DELETE2(reg_EVENT_LAST           ,_param->_nb_front_end,_param->_nb_context [it1]);
         DELETE2(reg_EVENT_LAST_NUM_BANK  ,_param->_nb_front_end,_param->_nb_context [it1]);
         DELETE2(reg_EVENT_LAST_NUM_PTR   ,_param->_nb_front_end,_param->_nb_context [it1]);
+
+        DELETE2(reg_EVENT_NEXT_STOP      ,_param->_nb_front_end,_param->_nb_context [it1]);
+        DELETE2(reg_EVENT_NEXT_PACKET    ,_param->_nb_front_end,_param->_nb_context [it1]);
 
 //      DELETE2(reg_PC_PREVIOUS          ,_param->_nb_front_end,_param->_nb_context [it1]);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_commit.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_commit.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_commit.cpp	(revision 123)
@@ -23,4 +23,7 @@
     log_begin(Commit_unit,FUNCTION);
     log_function(Commit_unit,FUNCTION,_name.c_str());
+
+    if (PORT_READ(in_NRESET))
+      {
 
 #ifdef STATISTICS
@@ -96,4 +99,10 @@
     for (uint32_t i=0; i<_param->_nb_inst_commit; i++)
       PORT_WRITE(out_COMMIT_ACK [i],commit_ack [i]);
+      }
+    else
+      {
+        for (uint32_t i=0; i<_param->_nb_inst_commit; i++)
+          PORT_WRITE(out_COMMIT_ACK [i],0);
+      }
     
     log_end(Commit_unit,FUNCTION);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_insert.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_insert.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_insert.cpp	(revision 123)
@@ -24,4 +24,6 @@
     log_function(Commit_unit,FUNCTION,_name.c_str());
 
+    if (PORT_READ(in_NRESET))
+      {
     Tcontrol_t bank_full         [_param->_nb_bank];
     Tcontrol_t insert_ack        [_param->_nb_rename_unit][_param->_max_nb_inst_insert];
@@ -136,5 +138,15 @@
 #endif
 	}
-    
+      }    
+    else
+      {
+        for (uint32_t i=0; i<_param->_nb_bank; i++)
+          internal_BANK_INSERT_VAL  [i] = false;
+        for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_inst_insert[i]; j++)
+            PORT_WRITE(out_INSERT_ACK       [i][j],0);
+
+      }
+
     log_end(Commit_unit,FUNCTION);
   };
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_retire.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_retire.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMealy_retire.cpp	(revision 123)
@@ -24,4 +24,6 @@
     log_function(Commit_unit,FUNCTION,_name.c_str());
 
+    if (PORT_READ(in_NRESET))
+      {
     Tcontrol_t retire_val          [_param->_nb_rename_unit][_param->_max_nb_inst_retire];
     uint32_t   num_inst_retire     [_param->_nb_rename_unit];
@@ -186,6 +188,6 @@
 
                   // if future event, don't update after this event
-                  if (reg_EVENT_STOP [front_end_id][context_id] and
-                      (reg_EVENT_PACKET [entry->front_end_id][entry->context_id]  == packet))
+                  if ((reg_EVENT_STATE  [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT) and
+                      (reg_EVENT_PACKET [entry->front_end_id][entry->context_id] == packet))
                     bypass = false;
 	      }
@@ -211,4 +213,11 @@
 	  PORT_WRITE(out_SPR_WRITE_SR_OV     [i][j], spr_write_sr_ov     [i][j]);
 	}
+      }
+    else
+      {
+        for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
+          for (uint32_t j=0; j<_param->_nb_inst_retire[i]; j++)
+            PORT_WRITE(out_RETIRE_VAL [i][j],0);
+      }
 
     log_end(Commit_unit,FUNCTION);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMoore.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMoore.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_genMoore.cpp	(revision 123)
@@ -24,4 +24,6 @@
     log_function(Commit_unit,FUNCTION,_name.c_str());
 
+    if (PORT_READ(in_NRESET))
+      {
     // ===================================================================
     // =====[ REEXECUTE ]=================================================
@@ -105,5 +107,4 @@
 
 	  internal_REEXECUTE_VAL      [i] = val;
-	  PORT_WRITE(out_REEXECUTE_VAL[i], internal_REEXECUTE_VAL [i]);
 	}
     }
@@ -148,5 +149,6 @@
 
                   // don't complete a branch when rob manage an present event
-		  if ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NO_EVENT) and
+		  if (((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NO_EVENT) or
+                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
                       (state == ROB_BRANCH_COMPLETE))
 		    {
@@ -154,7 +156,7 @@
 
                       // test if have a future event (stop is set)
-                      log_printf(TRACE,Commit_unit,FUNCTION,"      * reg_EVENT_STOP   : %d",reg_EVENT_STOP [front_end_id][context_id]);
-
-                      if (reg_EVENT_STOP [front_end_id][context_id])
+//                       log_printf(TRACE,Commit_unit,FUNCTION,"      * reg_EVENT_STOP   : %d",reg_EVENT_STOP [front_end_id][context_id]);
+
+                      if (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)
                         {
                           // Have future event, can complete the branch if the event is most speculative than this branchement
@@ -204,5 +206,4 @@
 
 	  internal_BRANCH_COMPLETE_VAL [i] = val;
-	  PORT_WRITE(out_BRANCH_COMPLETE_VAL [i], internal_BRANCH_COMPLETE_VAL [i]);
 	}
     }
@@ -275,6 +276,4 @@
 	}
       
-      PORT_WRITE(out_UPDATE_VAL, internal_UPDATE_VAL);
-
       log_printf(TRACE,Commit_unit,FUNCTION,"  * UPDATE (end)");
     }
@@ -283,10 +282,22 @@
     // =====[ NB_INST ]===================================================
     // ===================================================================
-    for (uint32_t i=0; i<_param->_nb_front_end; i++)
-      for (uint32_t j=0; j<_param->_nb_context [i]; j++)
-	{
-	  PORT_WRITE(out_NB_INST_COMMIT_ALL [i][j], reg_NB_INST_COMMIT_ALL [i][j]);
-	  PORT_WRITE(out_NB_INST_COMMIT_MEM [i][j], reg_NB_INST_COMMIT_MEM [i][j]);
-	}
+    {
+#ifdef DEBUG_TEST
+      bool empty = true;
+#endif
+      for (uint32_t i=0; i<_param->_nb_front_end; i++)
+        for (uint32_t j=0; j<_param->_nb_context [i]; j++)
+          {
+#ifdef DEBUG_TEST
+            empty &= (reg_NB_INST_COMMIT_ALL [i][j] == 0);
+#endif
+            PORT_WRITE(out_NB_INST_COMMIT_ALL [i][j], reg_NB_INST_COMMIT_ALL [i][j]);
+            PORT_WRITE(out_NB_INST_COMMIT_MEM [i][j], reg_NB_INST_COMMIT_MEM [i][j]);
+          }
+#ifdef DEBUG_TEST
+      PORT_WRITE(out_INFO_ROB_EMPTY,empty);
+#endif
+    }
+
 
     // ===================================================================
@@ -296,14 +307,49 @@
       for (uint32_t j=0; j<_param->_nb_context [i]; j++)
         {
-//        bool flush = reg_EVENT_FLUSH [i][j];
-          bool flush = (((reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_EVENT) or
-                         (reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_WAIT_DECOD)) and
-                        not reg_EVENT_CAN_RESTART[i][j]);
+//           bool flush = (((reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_EVENT) or
+//                          (reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_WAIT_DECOD)) and
+//                         not reg_EVENT_CAN_RESTART[i][j]);
 
           PORT_WRITE(out_RETIRE_EVENT_STATE [i][j], commit_event_state_to_event_state(reg_EVENT_STATE[i][j]));
-          PORT_WRITE(out_RETIRE_EVENT_FLUSH [i][j], flush);
-          PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], reg_EVENT_STOP [i][j]);
+//        PORT_WRITE(out_RETIRE_EVENT_FLUSH [i][j], flush);
+//        PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], reg_EVENT_STOP [i][j]);
+          PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], ((reg_EVENT_STATE [i][j] == COMMIT_EVENT_STATE_NOT_YET_EVENT) or
+                                                     reg_EVENT_NEXT_STOP [i][j]));
         }
-
+      }
+    else
+      {
+        for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
+          {
+            internal_REEXECUTE_VAL      [i] = 0;
+//             internal_REEXECUTE_NUM_BANK [i] = num_bank;
+          }
+
+        for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+          {
+            internal_BRANCH_COMPLETE_VAL [i] = 0;
+//             internal_BRANCH_COMPLETE_NUM_BANK           [i] = num_bank;
+          }
+
+        internal_UPDATE_VAL = 0;
+//       internal_UPDATE_NUM_BANK = reg_NUM_BANK_HEAD;
+
+
+        for (uint32_t i=0; i<_param->_nb_front_end; i++)
+          for (uint32_t j=0; j<_param->_nb_context [i]; j++)
+            {
+              PORT_WRITE(out_RETIRE_EVENT_STATE [i][j], commit_event_state_to_event_state(COMMIT_EVENT_STATE_NO_EVENT));
+//            PORT_WRITE(out_RETIRE_EVENT_FLUSH [i][j], flush);
+//            PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], reg_EVENT_STOP [i][j]);
+              PORT_WRITE(out_RETIRE_EVENT_STOP  [i][j], true);
+            }
+      }
+
+      for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
+        PORT_WRITE(out_REEXECUTE_VAL[i], internal_REEXECUTE_VAL [i]);
+      for (uint32_t i=0; i<_param->_nb_inst_branch_complete; i++)
+        PORT_WRITE(out_BRANCH_COMPLETE_VAL [i], internal_BRANCH_COMPLETE_VAL [i]);
+      PORT_WRITE(out_UPDATE_VAL, internal_UPDATE_VAL);
+        
     log_end(Commit_unit,FUNCTION);
   };
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_transition.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_transition.cpp	(revision 122)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Commit_unit/src/Commit_unit_transition.cpp	(revision 123)
@@ -53,6 +53,8 @@
               reg_EVENT_STATE           [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
 //            reg_EVENT_FLUSH           [i][j] = false;
-              reg_EVENT_STOP            [i][j] = false;
+//            reg_EVENT_STOP            [i][j] = false;
               reg_EVENT_LAST            [i][j] = false;
+
+              reg_EVENT_NEXT_STOP       [i][j] = false;
 
 //            reg_PC_PREVIOUS           [i][j] = (0x100-4)>>2;
@@ -86,8 +88,8 @@
               //   * and decod_queue is empty
               //   * and have an event or have a futur event
-              if (not reg_EVENT_CAN_RESTART [i][j] and
-                   (PORT_READ(in_NB_INST_DECOD_ALL [i][j]) == 0) and
-                   (reg_EVENT_STOP [i][j] or (reg_EVENT_STATE [i][j] != COMMIT_EVENT_STATE_NO_EVENT)))
-                reg_EVENT_CAN_RESTART [i][j] = true;
+//               if (not reg_EVENT_CAN_RESTART [i][j] and
+//                    (PORT_READ(in_NB_INST_DECOD_ALL [i][j]) == 0) and
+//                    (reg_EVENT_STOP [i][j] or (reg_EVENT_STATE [i][j] != COMMIT_EVENT_STATE_NO_EVENT)))
+//                 reg_EVENT_CAN_RESTART [i][j] = true;
 
               // Test event state
@@ -100,7 +102,7 @@
                       {
                         // A minor optimisation : test if wait_decod is previously empty.
-                        if (not reg_EVENT_CAN_RESTART [i][j])
-                          reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_DECOD;
-                        else
+//                         if (not reg_EVENT_CAN_RESTART [i][j])
+//                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_DECOD;
+//                         else
                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_END; 
                       }
@@ -108,20 +110,20 @@
                     break;
                   }
-                case COMMIT_EVENT_STATE_WAIT_DECOD : 
-                  {
-                    // Wait flush of decod_queue.
-                    // Test if can restart now
-                    if (reg_EVENT_CAN_RESTART [i][j])
-                      {
-                        //reg_EVENT_FLUSH [i][j] = false;
-
-                        // A minor optimisation : test if the last element is already retire
-                        if (not reg_EVENT_LAST [i][j])
-                          reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_END;
-                        else
-                          reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_END; 
-                      }
-                    break;
-                  }
+//                 case COMMIT_EVENT_STATE_WAIT_DECOD : 
+//                   {
+//                     // Wait flush of decod_queue.
+//                     // Test if can restart now
+//                     if (reg_EVENT_CAN_RESTART [i][j])
+//                       {
+//                         //reg_EVENT_FLUSH [i][j] = false;
+
+//                         // A minor optimisation : test if the last element is already retire
+//                         if (not reg_EVENT_LAST [i][j])
+//                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_WAIT_END;
+//                         else
+//                           reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_END; 
+//                       }
+//                     break;
+//                   }
                 case COMMIT_EVENT_STATE_WAIT_END : 
                   {
@@ -138,9 +140,22 @@
                     
                     // flush of re order buffer is finish
-                    reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
                     reg_EVENT_LAST  [i][j] = false;
+
+                    if (not reg_EVENT_NEXT_STOP [i][j])
+                      reg_EVENT_STATE [i][j] = COMMIT_EVENT_STATE_NO_EVENT;
+                    else
+                      {
+                        reg_EVENT_NEXT_STOP [i][j] = false;
+                        reg_EVENT_PACKET [i][j] = reg_EVENT_NEXT_PACKET [i][j];
+                        reg_EVENT_STATE         [i][j] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
+//                      reg_EVENT_STOP          [i][j] = true;
+                        reg_EVENT_LAST_NUM_BANK [i][j] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
+                        reg_EVENT_LAST_NUM_PTR  [i][j] = reg_NUM_PTR_TAIL;
+                      }
+
                     break;
                   }
                   //case COMMIT_EVENT_STATE_NO_EVENT : 
+                  //case COMMIT_EVENT_STATE_NOT_YET_EVENT : 
                 default : break;
                 }
@@ -296,20 +311,21 @@
                       //     * or present_event 
                       //   * and not can_restart (previous empty decod queue), because between the event_stop (branch_complete) and the state event (miss in head), many cycle is occured.
-                      bool flush = ((// present event
-                                     ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
-                                      (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD)) or
-                                     // futur event
-                                     reg_EVENT_STOP [front_end_id][context_id])
-                                    // can't restart
-                                    and not reg_EVENT_CAN_RESTART[front_end_id][context_id]
-                                    );
-
-                      if (flush)
-                        {
-                          // A new invalid instruction is push in rob -> new last instruction
-                          reg_EVENT_LAST          [front_end_id][context_id] = false;
-                          reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = num_bank;
-                          reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = ptr;
-                        }
+//                       bool flush = ((// present event
+//                                      ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
+//                                       (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD)
+//                                       ) or
+//                                      futur event
+//                                      reg_EVENT_STOP [front_end_id][context_id])
+//                                     // can't restart
+//                                     and not reg_EVENT_CAN_RESTART[front_end_id][context_id]
+//                                     );
+
+//                       if (flush)
+//                         {
+//                           // A new invalid instruction is push in rob -> new last instruction
+//                           reg_EVENT_LAST          [front_end_id][context_id] = false;
+//                           reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = num_bank;
+//                           reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = ptr;
+//                         }
                       
                       // Update pointer
@@ -359,4 +375,6 @@
 		    // find the good entry !!!
 		    entry_t *       entry        = internal_BANK_COMMIT_ENTRY [i][j];
+
+		    log_printf(TRACE,Commit_unit,FUNCTION,"    * ptr        : %d",entry->ptr);
                                                  
 		  //Toperation_t    operation    = PORT_READ(in_COMMIT_OPERATION   [x]);
@@ -480,42 +498,82 @@
 
                     // Commit an instruction ... 
-                    // Test if have an event (miss_speculation or exception) and not manage a previous event
-                    // if yes, this instruction would modify state machine. Also stop Re Order Buffer
-
-//                  bool flush = reg_EVENT_FLUSH [entry->front_end_id][entry->context_id];
-                    bool flush = ((reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_EVENT) or
-                                  (reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
-                                  (reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_WAIT_END));
-                    
-                    if ((have_exception or have_miss_speculation) and (not flush))
+                    // Test if have an event (miss_speculation or exception)
+
+                    if (have_exception or have_miss_speculation)
                       {
+                        // Two case :
+                        // if no previous manage event -> generate an event
+                        // if    previous manage event -> next generate an event
+
+//                      bool flush = reg_EVENT_FLUSH [front_end_id][context_id];
+                        bool flush = ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
+//                                    (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
+                                      (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_END) or
+                                      (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_END)
+                                      );
+                        
                         uint32_t packet = ((entry->ptr << _param->_shift_num_slot) | i);
-                        
-                        // test have a previous event detected (event_stop = 1)
-                        // if yes, test if the actual event if "before (in order)" that the previous event
-                        if (reg_EVENT_STOP [entry->front_end_id][entry->context_id])
+                        uint32_t _top   = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
+                            
+                        if (not flush)
                           {
-                            // Compare packet_id (by construction instruction is insert in order by increase packet_id)
-
-                            uint32_t _top = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
-                            uint32_t _old = reg_EVENT_PACKET [entry->front_end_id][entry->context_id];
-                            uint32_t _new = packet;
-                            if (_old < _top) _old = _old+_param->_size_queue;
-                            if (_new < _top) _new = _new+_param->_size_queue;
-                            if (_new < _old) reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
+                            bool     can    = true;
+                            // test have a previous event detected (event_stop = 1)
+                            // if yes, test if the actual event if "before (in order)" that the previous event
+                            if (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)
+                              {
+                                // Compare packet_id (by construction instruction is insert in order by increase packet_id)
+                                
+                                uint32_t _old = reg_EVENT_PACKET [front_end_id][context_id];
+                                uint32_t _new = packet;
+                                if (_old < _top) _old = _old+_param->_size_queue;
+                                if (_new < _top) _new = _new+_param->_size_queue;
+                                if (_new < _old) reg_EVENT_PACKET [front_end_id][context_id] = packet;
+                                else can = false;
+                              }
+                            else
+                              reg_EVENT_PACKET [front_end_id][context_id] = packet;
+                            
+                            if (can)
+                              {
+                                // have an error, stop issue instruction
+                                reg_EVENT_STATE         [front_end_id][context_id] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
+                                //                      reg_EVENT_STOP          [front_end_id][context_id] = true;
+                                
+                                reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
+                                reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = reg_NUM_PTR_TAIL;
+                              }
                           }
                         else
-                          reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
-                        
-                        // have an error, stop issue instruction
-                        reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
-//                         reg_EVENT_NUM_BANK      [entry->front_end_id][entry->context_id] = i;
-//                         reg_EVENT_NUM_PTR       [entry->front_end_id][entry->context_id] = entry->ptr;
-
-//                      reg_EVENT_CAN_RESTART   [entry->front_end_id][entry->context_id] = false;
-                        reg_EVENT_LAST_NUM_BANK [entry->front_end_id][entry->context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
-                        reg_EVENT_LAST_NUM_PTR  [entry->front_end_id][entry->context_id] = reg_NUM_PTR_TAIL;
+                          {
+                            bool find = true;
+
+                            // already manage an event.
+                            if (reg_EVENT_NEXT_STOP [front_end_id][context_id])
+                              {
+                                // after last ?
+                                uint32_t _old = reg_EVENT_NEXT_PACKET [front_end_id][context_id];
+                                uint32_t _new = packet;
+                                if (_old < _top) _old = _old+_param->_size_queue;
+                                if (_new < _top) _new = _new+_param->_size_queue;
+                                if (_new > _old) reg_EVENT_NEXT_PACKET [front_end_id][context_id] = packet;
+                                find = false;
+                              }
+                            else
+                              {
+                                // after last ?
+                                uint32_t _old = ((reg_EVENT_LAST_NUM_PTR [front_end_id][context_id] << _param->_shift_num_slot) | reg_EVENT_LAST_NUM_BANK [front_end_id][context_id]);
+                                uint32_t _new = packet;
+                                if (_old < _top) _old = _old+_param->_size_queue;
+                                if (_new < _top) _new = _new+_param->_size_queue;
+                                if (_new > _old) reg_EVENT_NEXT_PACKET [front_end_id][context_id] = packet;
+                                find = false;
+                              }
+
+                            if (find)
+                            reg_EVENT_NEXT_STOP [front_end_id][context_id] = true; // in all case : need stop
+                          }
                       }
-                    
+
 		    // Update Re Order Buffer
 		    entry->state        = state;
@@ -633,20 +691,18 @@
 	              {
                           reg_EVENT_STATE         [front_end_id][context_id] = COMMIT_EVENT_STATE_EVENT;
-//                        reg_EVENT_FLUSH         [front_end_id][context_id] = true;
-                          reg_EVENT_STOP          [front_end_id][context_id] = false; // instruction flow can continue
-//                        reg_EVENT_CAN_RESTART   [front_end_id][context_id] = false;
+//                        reg_EVENT_STOP          [front_end_id][context_id] = false; // instruction flow can continue
                           reg_EVENT_LAST          [front_end_id][context_id] = false;
                           // it the head !
                           reg_EVENT_PACKET        [front_end_id][context_id] = packet_id;
 	            
-                          // If event is an load_miss, many instruction can be inserted. 
-                          // -> new last instruction
-                          if (state == ROB_END_LOAD_MISS)
-                            {
-                            reg_EVENT_CAN_RESTART   [front_end_id][context_id] = false;
+//                           // If event is an load_miss, many instruction can be inserted. 
+//                           // -> new last instruction
+//                           if (state == ROB_END_LOAD_MISS)
+//                             {
+// //                             reg_EVENT_CAN_RESTART   [front_end_id][context_id] = false;
                             
-                            reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
-                            reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = reg_NUM_PTR_TAIL;
-                            }
+//                             reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
+//                             reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] = reg_NUM_PTR_TAIL;
+//                             }
                         }
 	            
@@ -654,5 +710,6 @@
                     //   * need event
                     //   * packet id = last packet id
-                    if ((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT) and
+                    if (((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT     ) and
+                         (reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
                         (reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] == num_bank            ) and
                         (reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] == entry->ptr          ))
@@ -666,8 +723,4 @@
 	            // Update pointer
 	            reg_NUM_BANK_HEAD = (num_bank+1)%_param->_nb_bank;
-                    
-	            // Remove entry
-	            delete entry;
-	            _rob [num_bank].pop_front();
                     
                     // Reset watch dog timer because have transaction on retire interface
@@ -708,4 +761,8 @@
 	            }
 #endif	    
+
+	            // Remove entry
+	            delete entry;
+	            _rob [num_bank].pop_front();
 	          }
 	      }
@@ -775,8 +832,9 @@
               if (miss)
                 {
+                  bool     can    = true;
                   uint32_t packet = ((entry->ptr << _param->_shift_num_slot) | num_bank);
                       
                   // test if this packet is before previous event
-                  if (reg_EVENT_STOP [entry->front_end_id][entry->context_id])
+                  if (reg_EVENT_STATE [entry->front_end_id][entry->context_id] == COMMIT_EVENT_STATE_NOT_YET_EVENT)
                     {
                       uint32_t _top = ((_rob[ reg_NUM_BANK_HEAD].front()->ptr << _param->_shift_num_slot) | reg_NUM_BANK_HEAD);
@@ -786,17 +844,20 @@
                       if (_new < _top) _new = _new+_param->_size_queue;
                       if (_new < _old) reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
+                      else can = false;
                     }
                   else
                     reg_EVENT_PACKET [entry->front_end_id][entry->context_id] = packet;
 
-                  // In all case, stop instruction flow
-                  reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
-//                   reg_EVENT_NUM_BANK      [entry->front_end_id][entry->context_id] = num_bank;
-//                   reg_EVENT_NUM_PTR       [entry->front_end_id][entry->context_id] = entry->ptr;
-
-                  reg_EVENT_CAN_RESTART   [entry->front_end_id][entry->context_id] = false;
-
-                  reg_EVENT_LAST_NUM_BANK [entry->front_end_id][entry->context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
-                  reg_EVENT_LAST_NUM_PTR  [entry->front_end_id][entry->context_id] = reg_NUM_PTR_TAIL;
+                  if (can)
+                    {
+                      // In all case, stop instruction flow
+                      reg_EVENT_STATE         [entry->front_end_id][entry->context_id] = COMMIT_EVENT_STATE_NOT_YET_EVENT;
+//                    reg_EVENT_STOP          [entry->front_end_id][entry->context_id] = true;
+
+//                    reg_EVENT_CAN_RESTART   [entry->front_end_id][entry->context_id] = false;
+
+                      reg_EVENT_LAST_NUM_BANK [entry->front_end_id][entry->context_id] = ((reg_NUM_BANK_TAIL==0)?_param->_nb_bank:reg_NUM_BANK_TAIL)-1;
+                      reg_EVENT_LAST_NUM_PTR  [entry->front_end_id][entry->context_id] = reg_NUM_PTR_TAIL;
+                    }
                 }
 	    }
@@ -902,5 +963,5 @@
                       
                       bool         flush         = ((reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_EVENT) or
-                                                    (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
+//                                                  (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_DECOD) or
                                                     (reg_EVENT_STATE [front_end_id][context_id] == COMMIT_EVENT_STATE_WAIT_END));
                       bool         speculative   = entry->speculative and not (depth == depth_min);
@@ -1005,5 +1066,6 @@
                       
                       // Test if this instruction is the last of event
-                      if ((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT) and
+                      if (((reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NO_EVENT) and
+                           (reg_EVENT_STATE         [front_end_id][context_id] != COMMIT_EVENT_STATE_NOT_YET_EVENT)) and
                           (reg_EVENT_LAST_NUM_BANK [front_end_id][context_id] == num_bank            ) and
                           (reg_EVENT_LAST_NUM_PTR  [front_end_id][context_id] == entry->ptr          ))
@@ -1044,10 +1106,12 @@
             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STATE       : %s - %s",toString(reg_EVENT_STATE [i][j]).c_str(),toString(commit_event_state_to_event_state(reg_EVENT_STATE [i][j])).c_str());
 //          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_FLUSH       : %d",reg_EVENT_FLUSH [i][j]);
-            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STOP        : %d",reg_EVENT_STOP  [i][j]);
-//             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT             : %d (bank %d, ptr %d)",((reg_EVENT_NUM_PTR [i][j] << _param->_shift_num_slot) | reg_EVENT_NUM_BANK [i][j]), reg_EVENT_NUM_BANK [i][j],reg_EVENT_NUM_PTR [i][j]);
-            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_CAN_RESTART : %d",reg_EVENT_CAN_RESTART [i][j]);
+//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_STOP        : %d",reg_EVENT_STOP  [i][j]);
+//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT             : %d (bank %d, ptr %d)",((reg_EVENT_NUM_PTR [i][j] << _param->_shift_num_slot) | reg_EVENT_NUM_BANK [i][j]), reg_EVENT_NUM_BANK [i][j],reg_EVENT_NUM_PTR [i][j]);
+//          log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_CAN_RESTART : %d",reg_EVENT_CAN_RESTART [i][j]);
             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_PACKET      : %d",reg_EVENT_PACKET[i][j]);
             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_LAST        : %d",reg_EVENT_LAST [i][j]);
             log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_LAST        : %d (bank %d, ptr %d)",((reg_EVENT_LAST_NUM_PTR [i][j] << _param->_shift_num_slot) | reg_EVENT_LAST_NUM_BANK [i][j]), reg_EVENT_LAST_NUM_BANK [i][j],reg_EVENT_LAST_NUM_PTR [i][j]);
+            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_NEXT_STOP   : %d",reg_EVENT_NEXT_STOP  [i][j]);
+            log_printf(TRACE,Commit_unit,FUNCTION,"      * EVENT_NEXT_PACKET : %d",reg_EVENT_NEXT_PACKET[i][j]);
             log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_ALL       : %d",reg_NB_INST_COMMIT_ALL[i][j]);
             log_printf(TRACE,Commit_unit,FUNCTION,"      * NB_INST_MEM       : %d",reg_NB_INST_COMMIT_MEM[i][j]);
@@ -1065,5 +1129,8 @@
         }
 
-      bool all_empty = false;
+      bool     all_empty   = false;
+      uint32_t nb_write_rd = 0;
+      uint32_t nb_write_re = 0;
+
       while (not all_empty)
         {
@@ -1078,4 +1145,7 @@
                 {
                   all_empty = false;
+
+                  nb_write_rd += ((*it)->write_rd)?1:0;
+                  nb_write_re += ((*it)->write_re)?1:0;
 
                   log_printf(TRACE,Commit_unit,FUNCTION,"        [%.4d][%.4d] (%.4d) %.4d %.4d %.4d %.4d, %.3d %.3d, %.1d, %.1d %.4d, %.1d %.4d, %s",
@@ -1130,4 +1200,7 @@
             }
         }
+
+      log_printf(TRACE,Commit_unit,FUNCTION,"    * nb_write_rd   : %d",nb_write_rd);
+      log_printf(TRACE,Commit_unit,FUNCTION,"    * nb_write_re   : %d",nb_write_re);
     }
 #endif
