Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/SelfTest/src/test.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/SelfTest/src/test.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/SelfTest/src/test.cpp	(revision 110)
@@ -333,5 +333,5 @@
 	  }
 
-      bool test_size = issue_queue.size() <= _param->_size_queue;
+      bool test_size = issue_queue.size() <= (_param->_size_queue+_param->_size_reexecute_queue);
       TEST(bool,test_size,true);
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Issue_queue.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Issue_queue.h	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Issue_queue.h	(revision 110)
@@ -144,13 +144,17 @@
     // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
   private   : std::list<entry_t*>           * _issue_queue;
+  private   : std::list<entry_t*>             _reexecute_queue;
   
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   private   : Tcontrol_t                    * internal_BANK_IN_ACK              ;//[nb_bank]
-  private   : bool                          * internal_BANK_IN_IS_REEXECUTE     ;//[nb_bank]
   private   : uint32_t                      * internal_BANK_IN_NUM_RENAME_UNIT  ;//[nb_bank]
   private   : uint32_t                      * internal_BANK_IN_NUM_INST         ;//[nb_bank]
 
-  private   : Tcontrol_t                    * internal_BANK_OUT_VAL             ;//[nb_bank]
-  private   : uint32_t                      * internal_BANK_OUT_NUM_INST        ;//[nb_bank]
+  private   : Tcontrol_t                    * internal_ISSUE_OUT_VAL            ;//[nb_inst_issue]
+  private   : Tcontrol_t                    * internal_ISSUE_OUT_FROM_REEXECUTE ;//[nb_inst_issue]
+  private   : uint32_t                      * internal_ISSUE_OUT_NUM_BANK       ;//[nb_inst_issue]
+  private   : entry_t *                     * internal_ISSUE_OUT_ENTRY          ;//[nb_inst_issue]
+
+  private   : Tcontrol_t                    * internal_REEXECUTE_ACK            ;//[nb_inst_reexecute]
 #endif
 
@@ -187,5 +191,4 @@
   public  : void        transition                (void);
   public  : void        genMoore                  (void);
-  public  : void        genMealy                  (void);
 #endif					       
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Parameters.h
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Parameters.h	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Parameters.h	(revision 110)
@@ -45,6 +45,7 @@
   public : bool           ** _table_routing           ;//[nb_rename_unit][nb_inst_issue]
   public : bool           ** _table_issue_type        ;//[nb_inst_issue][nb_type]
+  public : uint32_t          _size_reexecute_queue    ;
 
-  public : uint32_t          _nb_bank_select_out      ;
+//public : uint32_t          _nb_bank_select_out      ;
   public : uint32_t          _max_nb_inst_rename      ;
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue.cpp	(revision 110)
@@ -95,44 +95,4 @@
 # endif    
 
-	log_printf(INFO,Issue_queue,FUNCTION,_("<%s> : Method - genMealy"),_name.c_str());
-
-	SC_METHOD (genMealy);
-	dont_initialize ();
-	sensitive << (*(in_CLOCK)).neg(); // need internal register
-	for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
-	  sensitive << (*(in_REEXECUTE_VAL  [i])) 
-		    << (*(in_REEXECUTE_TYPE [i]));
-	for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
-	  for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
-	    sensitive // << (*(in_ISSUE_IN_VAL  [i][j])) 
-		      << (*(in_ISSUE_IN_TYPE [i][j]));
-	
-# ifdef SYSTEMCASS_SPECIFIC
-	// List dependency information
-	for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
-	  for (uint32_t x=0; x<_param->_nb_inst_reexecute; x++)
-	    {
-	      (*(out_REEXECUTE_ACK [i])) (*(in_REEXECUTE_VAL  [x]));
-	      (*(out_REEXECUTE_ACK [i])) (*(in_REEXECUTE_TYPE [x]));
-	    }
-
-	for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
-	  for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
-	    {
-	      for (uint32_t x=0; x<_param->_nb_inst_reexecute; x++)
-		{
-		  (*(out_ISSUE_IN_ACK [i][j])) (*(in_REEXECUTE_VAL  [x]));
-		  (*(out_ISSUE_IN_ACK [i][j])) (*(in_REEXECUTE_TYPE [x]));
-		}
-
-	      for (uint32_t x=0; x<_param->_nb_rename_unit; x++)
-		for (uint32_t y=0; y<_param->_nb_inst_rename[x]; y++)
-		  {
-		    (*(out_ISSUE_IN_ACK [i][j])) (*(in_ISSUE_IN_VAL  [x][y]));
-		    (*(out_ISSUE_IN_ACK [i][j])) (*(in_ISSUE_IN_TYPE [x][y]));
-		  }
-	    }
-# endif    
-	
 #endif
       }
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_allocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_allocation.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_allocation.cpp	(revision 110)
@@ -141,14 +141,17 @@
       {
     // ~~~~~[ Registers ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
-    _issue_queue = new std::list<entry_t*> [_param->_nb_bank];
+    _issue_queue     = new std::list<entry_t*> [_param->_nb_bank];
 
     // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    internal_BANK_IN_ACK             = new Tcontrol_t [_param->_nb_bank];
-    internal_BANK_IN_IS_REEXECUTE    = new bool       [_param->_nb_bank];
-    internal_BANK_IN_NUM_RENAME_UNIT = new uint32_t   [_param->_nb_bank];
-    internal_BANK_IN_NUM_INST        = new uint32_t   [_param->_nb_bank];
-    
-    internal_BANK_OUT_VAL            = new Tcontrol_t [_param->_nb_bank];
-    internal_BANK_OUT_NUM_INST       = new uint32_t   [_param->_nb_bank];
+    ALLOC1(internal_BANK_IN_ACK             ,Tcontrol_t,_param->_nb_bank);
+    ALLOC1(internal_BANK_IN_NUM_RENAME_UNIT ,uint32_t  ,_param->_nb_bank);
+    ALLOC1(internal_BANK_IN_NUM_INST        ,uint32_t  ,_param->_nb_bank);
+
+    ALLOC1(internal_ISSUE_OUT_VAL           ,Tcontrol_t,_param->_nb_inst_issue);
+    ALLOC1(internal_ISSUE_OUT_FROM_REEXECUTE,Tcontrol_t,_param->_nb_inst_issue);
+    ALLOC1(internal_ISSUE_OUT_NUM_BANK      ,uint32_t  ,_param->_nb_inst_issue);
+    ALLOC1(internal_ISSUE_OUT_ENTRY         ,entry_t * ,_param->_nb_inst_issue);
+
+    ALLOC1(internal_REEXECUTE_ACK           ,Tcontrol_t,_param->_nb_inst_reexecute);
       }
 
@@ -164,9 +167,9 @@
     _priority_out = new generic::priority::Priority (_name+"_priority_out"  ,
 						     _param->_priority      ,
-						     _param->_nb_bank_select_out,
-						     _param->_nb_bank_select_out);
+						     _param->_nb_bank,
+						     _param->_nb_bank);
 
-    _priority_reg = new generic::priority::Priority (_name+"_priority_reg",
-						     PRIORITY_ROUND_ROBIN ,
+    _priority_reg = new generic::priority::Priority (_name+"_priority_reg"  ,
+						     _param->_priority      ,
 						     _param->_nb_bank,
 						     _param->_nb_bank);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_deallocation.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_deallocation.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_deallocation.cpp	(revision 110)
@@ -98,11 +98,14 @@
         
         // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        delete [] internal_BANK_IN_ACK            ;
-        delete [] internal_BANK_IN_IS_REEXECUTE   ;
-        delete [] internal_BANK_IN_NUM_RENAME_UNIT;
-        delete [] internal_BANK_IN_NUM_INST       ;
-        
-        delete [] internal_BANK_OUT_VAL           ;
-        delete [] internal_BANK_OUT_NUM_INST      ;
+        DELETE1(internal_BANK_IN_ACK             ,_param->_nb_bank);
+        DELETE1(internal_BANK_IN_NUM_RENAME_UNIT ,_param->_nb_bank);
+        DELETE1(internal_BANK_IN_NUM_INST        ,_param->_nb_bank);
+
+        DELETE1(internal_ISSUE_OUT_VAL           ,_param->_nb_inst_issue);
+        DELETE1(internal_ISSUE_OUT_FROM_REEXECUTE,_param->_nb_inst_issue);
+        DELETE1(internal_ISSUE_OUT_NUM_BANK      ,_param->_nb_inst_issue);
+        DELETE1(internal_ISSUE_OUT_ENTRY         ,_param->_nb_inst_issue);
+
+        DELETE1(internal_REEXECUTE_ACK           ,_param->_nb_inst_reexecute);
       }
     
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_genMealy.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_genMealy.cpp	(revision 109)
+++ 	(revision )
@@ -1,133 +1,0 @@
-#ifdef SYSTEMC
-/*
- * $Id$
- *
- * [ Description ]
- * 
- */
-
-#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/include/Issue_queue.h"
-
-namespace morpheo                    {
-namespace behavioural {
-namespace core {
-namespace multi_ooo_engine {
-namespace ooo_engine {
-namespace issue_queue {
-
-
-#undef  FUNCTION
-#define FUNCTION "Issue_queue::genMealy"
-  void Issue_queue::genMealy (void)
-  {
-    log_begin(Issue_queue,FUNCTION);
-    log_function(Issue_queue,FUNCTION,_name.c_str());
-
-    Tcontrol_t bank_full         [_param->_nb_bank];
-    Tcontrol_t issue_ack         [_param->_nb_rename_unit][_param->_max_nb_inst_rename];
-    Tcontrol_t reexecute_ack     [_param->_nb_inst_reexecute];
-    bool       can_rename_select [_param->_nb_rename_unit];
-    
-    // Initialisation
-    for (uint32_t i=0; i<_param->_nb_bank; i++)
-      {
-	internal_BANK_IN_ACK  [i] = false;
-	bank_full [i] = not (_issue_queue[i].size() < _param->_size_bank); 
-      }
-    for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
-      {
-	can_rename_select [i] = true;
-	for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
-	  issue_ack [i][j] = false;
-      }
-    for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
-      reexecute_ack [i] = false;
-    
-    std::list<generic::priority::select_t> * select_reg = _priority_reg->select(); // same select for all issue
-
-    // Priority at the Reexecute instruction !
-    for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
-      // Test if have instruction
-      if (PORT_READ(in_REEXECUTE_VAL [i]))
-	{
-	  Ttype_t type = PORT_READ(in_REEXECUTE_TYPE [i]);
-	  
-	  // scan all bank
-	  for (std::list<generic::priority::select_t>::iterator it=select_reg->begin();
-	       it!=select_reg->end();
-	       it++)
-	    {
-	      uint32_t num_bank  = it->grp;
-	      uint32_t num_issue = num_bank/_param->_nb_bank_select_out;
-	      // test if bank is not busy (full or previous access) and if type match
-	      if (not internal_BANK_IN_ACK [num_bank] and not bank_full [num_bank] and _param->_table_issue_type[num_issue][type])
-		{
-		  // find
-		  reexecute_ack [i] = true;
-		  internal_BANK_IN_ACK          [num_bank] = true;
-		  internal_BANK_IN_IS_REEXECUTE [num_bank] = 1;
-		  internal_BANK_IN_NUM_INST     [num_bank] = i;
-		  break;
-		}
-	    }
-	}
-    
-    // issue_in interface
-    std::list<generic::priority::select_t> * select_in = _priority_in ->select(); // same select for all issue
-    for (std::list<generic::priority::select_t>::iterator it=select_in ->begin();
-	 it!=select_in ->end();
-	 it++)
-      {
-	uint32_t num_rename_unit = it->grp;
-	uint32_t num_inst_rename = it->elt;
-
-        // Test if have instruction 
-	if (can_rename_select [num_rename_unit]//  and 
-// 	    PORT_READ(in_ISSUE_IN_VAL [num_rename_unit][num_inst_rename])
-            )
-	  {
-	    Ttype_t type = PORT_READ(in_ISSUE_IN_TYPE [num_rename_unit][num_inst_rename]);
-	  
-	    // scan all bank
-	    for (std::list<generic::priority::select_t>::iterator it=select_reg->begin();
-		 it!=select_reg->end();
-		 it++)
-	      {
-		uint32_t num_bank  = it->grp;
-		uint32_t num_issue = num_bank/_param->_nb_bank_select_out;
-		// test if bank is not busy (full or previous access) and if type match
-		if (not internal_BANK_IN_ACK [num_bank] and not bank_full [num_bank] and _param->_table_issue_type[num_issue][type])
-		  {
-		    // find
-		    issue_ack [num_rename_unit][num_inst_rename] = true;
-		    internal_BANK_IN_ACK             [num_bank] = true;
-		    internal_BANK_IN_IS_REEXECUTE    [num_bank] = 0;
-		    internal_BANK_IN_NUM_RENAME_UNIT [num_bank] = num_rename_unit;
-		    internal_BANK_IN_NUM_INST        [num_bank] = num_inst_rename;
-		    break;
-		  }
-	      }
-
-	    // is a valid instruction, but it's not send at a bank
-	    //  ... invalid this rename_unit (because, rename in_order)
-	    can_rename_select [num_rename_unit] |= issue_ack [num_rename_unit][num_inst_rename];
-	  }
-      }
-    
-    for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
-      for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
-	PORT_WRITE(out_ISSUE_IN_ACK [i][j],issue_ack [i][j]);
-    for (uint32_t i=0; i<_param->_nb_inst_reexecute; i++)
-      PORT_WRITE(out_REEXECUTE_ACK [i],reexecute_ack [i]);
-
-    log_end(Issue_queue,FUNCTION);
-  };
-
-}; // end namespace issue_queue
-}; // end namespace ooo_engine
-}; // end namespace multi_ooo_engine
-}; // end namespace core
-
-}; // end namespace behavioural
-}; // end namespace morpheo              
-#endif
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_genMoore.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_genMoore.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_genMoore.cpp	(revision 110)
@@ -24,71 +24,202 @@
     log_function(Issue_queue,FUNCTION,_name.c_str());
 
-    for (uint32_t i=0; i<_param->_nb_bank; i++)
-      internal_BANK_OUT_VAL [i] = false;
-
-    std::list<generic::priority::select_t> * select = _priority_out->select(); // same select for all issue
-
-    uint32_t num_bank_offset = 0;
-    for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
+    // ===================================================================
+    // =====[ REEXECUTE_UNIT ]============================================
+    // ===================================================================
+    
+    for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
       {
-// 	log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d]",i);
-	Tcontrol_t val      = false;
-	uint32_t   num_bank = 0;
-
-	// find a non empty bank
-	for (std::list<generic::priority::select_t>::iterator it=select->begin();
-	     it!=select->end();
-	     it++)
-	  {
-	    num_bank=num_bank_offset+it->grp;
-	   
-// 	    log_printf(TRACE,Issue_queue,FUNCTION,"    * Bank [%d]",num_bank);
+        log_printf(TRACE,Issue_queue,FUNCTION,"  * REEXECUTE [%d]",i);
+
+        internal_REEXECUTE_ACK [i] = (_reexecute_queue.size()+i) < _param->_size_reexecute_queue;
+
+        log_printf(TRACE,Issue_queue,FUNCTION,"    * ACK : %d",internal_REEXECUTE_ACK [i]);
+
+        PORT_WRITE(out_REEXECUTE_ACK [i], internal_REEXECUTE_ACK [i]);
+      }
+
+    // ===================================================================
+    // =====[ ISSUE_IN ]==================================================
+    // ===================================================================
+    {
+      Tcontrol_t ack [_param->_nb_rename_unit][_param->_max_nb_inst_rename];
+
+      // Initialisation
+      for (uint32_t i=0; i<_param->_nb_bank; i++)
+        internal_BANK_IN_ACK  [i] = false;
+    
+      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
+        for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
+          ack [i][j] = false;
+    
+      std::list<generic::priority::select_t> * select_reg = _priority_reg->select(); // same select for all issue
+      
+      // issue_in interface
+      std::list<generic::priority::select_t> * select_in = _priority_in ->select(); // same select for all issue
+      for (std::list<generic::priority::select_t>::iterator it=select_in ->begin();
+           it!=select_in ->end();
+           it++)
+        {
+          // Get num interface
+          uint32_t num_rename_unit = it->grp;
+          uint32_t num_inst_rename = it->elt;
+
+          log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d][%d]",num_rename_unit,num_inst_rename);
+          
+          // scan all bank
+          for (std::list<generic::priority::select_t>::iterator it=select_reg->begin();
+               it!=select_reg->end();
+               it++)
+            {
+              uint32_t num_bank  = it->grp;
+
+              log_printf(TRACE,Issue_queue,FUNCTION,"    * BANK [%d]",num_bank);
+          
+              // test if bank is not busy (full or previous access)
+              if (not internal_BANK_IN_ACK [num_bank] and (_issue_queue[num_bank].size() < _param->_size_bank))
+                {
+                  log_printf(TRACE,Issue_queue,FUNCTION,"    * find");
+
+                  // find
+                  ack [num_rename_unit][num_inst_rename] = true;
+                  internal_BANK_IN_ACK             [num_bank] = true;
+                  internal_BANK_IN_NUM_RENAME_UNIT [num_bank] = num_rename_unit;
+                  internal_BANK_IN_NUM_INST        [num_bank] = num_inst_rename;
+		  
+                  break; // Stop scan
+                }
+              else
+                log_printf(TRACE,Issue_queue,FUNCTION,"    * not find");
+            }
+        }
+    
+      for (uint32_t i=0; i<_param->_nb_rename_unit; i++)
+        for (uint32_t j=0; j<_param->_nb_inst_rename[i]; j++)
+          PORT_WRITE(out_ISSUE_IN_ACK [i][j],ack [i][j]);
+    }
+
+    // ===================================================================
+    // =====[ ISSUE_OUT ]=================================================
+    // ===================================================================
+    {
+      Tcontrol_t val [_param->_nb_inst_issue];
+
+      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
+        val [i] = 0;
+
+      // From Reexecute_queue
+
+//       uint32_t num_reexecute_entry = 0;
+      for (std::list<entry_t*>::iterator it=_reexecute_queue.begin();
+           it!=_reexecute_queue.end();
+           ++it)
+        {
+          entry_t* entry = (*it);
+
+          for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
+            // test if no previous transaction and can accept this type
+            if ((val[i] == 0) and _param->_table_issue_type [i][entry->_type])
+              {
+                // find a issue port
+                val [i] = 1;
 	    
-	    if (not _issue_queue [num_bank].empty())
-	      {
-// 		log_printf(TRACE,Issue_queue,FUNCTION,"      * Not Empty !!!");
-		val = true;
-
-		internal_BANK_OUT_NUM_INST [num_bank] = i;
-		break; // quit scearch loop
-	      }
-	  }
-
-	PORT_WRITE(out_ISSUE_OUT_VAL [i], val);
-
-	if (val)
-	  {
-	    // have find a bank with a data
-	    internal_BANK_OUT_VAL [num_bank] = true;
-	
-	    entry_t* entry = _issue_queue [num_bank].front();
-	    
-	    if (_param->_have_port_context_id)
-	    PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
-	    if (_param->_have_port_front_end_id)
-	    PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
-	    if (_param->_have_port_rob_ptr  )
-	    PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
-	    PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
-	    PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
-	    PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
-	    if (_param->_have_port_load_queue_ptr)
-	    PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
-	    PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
-	    PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
-	    PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
-	    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
-	    PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
-	    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
-	    PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
-	    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
-	    PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
-	    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
-	    PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
-	    PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
-	  }
-
-	num_bank_offset += _param->_nb_bank_select_out;
-      }
+                if (_param->_have_port_context_id)
+	        PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
+	        if (_param->_have_port_front_end_id)
+	        PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
+	        if (_param->_have_port_rob_ptr  )
+	        PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
+	        PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
+	        PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
+	        PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
+	        if (_param->_have_port_load_queue_ptr)
+	        PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
+	        PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
+	        PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
+	        PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
+	        PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
+	        PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
+	        PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
+	        PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
+	        PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
+	        PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
+	        PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
+	        PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
+	        PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
+
+                internal_ISSUE_OUT_FROM_REEXECUTE [i] = true;
+//              internal_ISSUE_OUT_NUM_BANK       [i] = num_reexecute_entry;
+                internal_ISSUE_OUT_ENTRY          [i] = entry;
+
+                break; // stop scan
+              }
+//           num_reexecute_entry ++;
+        }
+
+      // From Issue_queue
+
+      std::list<generic::priority::select_t> * select = _priority_out->select(); // same select for all issue
+
+      for (std::list<generic::priority::select_t>::iterator it=select->begin();
+           it!=select->end();
+           it++)
+        {
+          uint32_t num_bank=it->grp;
+
+//        log_printf(TRACE,Issue_queue,Issue_queue,FUNCTION,"    * Bank [%d]",num_bank);
+
+          // Have instruction ?
+          if (not _issue_queue [num_bank].empty())
+            {
+// 	      log_printf(TRACE,Issue_queue,Issue_queue,FUNCTION,"      * Not Empty !!!");
+
+              entry_t* entry = _issue_queue [num_bank].front();
+              
+              for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
+                // test if no previous transaction and can accept this type
+                if ((val[i] == 0) and _param->_table_issue_type [i][entry->_type])
+                  {
+                    // find a issue port
+                    val [i] = 1;
+
+                    if (_param->_have_port_context_id)
+	            PORT_WRITE(out_ISSUE_OUT_CONTEXT_ID            [i], entry->_context_id           );
+	            if (_param->_have_port_front_end_id)
+	            PORT_WRITE(out_ISSUE_OUT_FRONT_END_ID          [i], entry->_front_end_id         );
+	            if (_param->_have_port_rob_ptr  )
+	            PORT_WRITE(out_ISSUE_OUT_PACKET_ID             [i], entry->_packet_id            );
+	            PORT_WRITE(out_ISSUE_OUT_OPERATION             [i], entry->_operation            );
+	            PORT_WRITE(out_ISSUE_OUT_TYPE                  [i], entry->_type                 );
+	            PORT_WRITE(out_ISSUE_OUT_STORE_QUEUE_PTR_WRITE [i], entry->_store_queue_ptr_write);
+	            if (_param->_have_port_load_queue_ptr)
+	            PORT_WRITE(out_ISSUE_OUT_LOAD_QUEUE_PTR_WRITE  [i], entry->_load_queue_ptr_write );
+	            PORT_WRITE(out_ISSUE_OUT_HAS_IMMEDIAT          [i], entry->_has_immediat         );
+	            PORT_WRITE(out_ISSUE_OUT_IMMEDIAT              [i], entry->_immediat             );
+	            PORT_WRITE(out_ISSUE_OUT_READ_RA               [i], entry->_read_ra              );
+	            PORT_WRITE(out_ISSUE_OUT_NUM_REG_RA            [i], entry->_num_reg_ra           );
+	            PORT_WRITE(out_ISSUE_OUT_READ_RB               [i], entry->_read_rb              );
+	            PORT_WRITE(out_ISSUE_OUT_NUM_REG_RB            [i], entry->_num_reg_rb           );
+	            PORT_WRITE(out_ISSUE_OUT_READ_RC               [i], entry->_read_rc              );
+	            PORT_WRITE(out_ISSUE_OUT_NUM_REG_RC            [i], entry->_num_reg_rc           );
+	            PORT_WRITE(out_ISSUE_OUT_WRITE_RD              [i], entry->_write_rd             );
+	            PORT_WRITE(out_ISSUE_OUT_NUM_REG_RD            [i], entry->_num_reg_rd           );
+	            PORT_WRITE(out_ISSUE_OUT_WRITE_RE              [i], entry->_write_re             );
+	            PORT_WRITE(out_ISSUE_OUT_NUM_REG_RE            [i], entry->_num_reg_re           );
+                    
+                    internal_ISSUE_OUT_FROM_REEXECUTE [i] = false;
+                    internal_ISSUE_OUT_NUM_BANK       [i] = num_bank;
+                    internal_ISSUE_OUT_ENTRY          [i] = entry;
+
+                    break; // stop scan
+                  }
+            }
+        }
+
+      for (uint32_t i=0; i<_param->_nb_inst_issue; i++)
+        {
+          internal_ISSUE_OUT_VAL [i] = val [i];
+          PORT_WRITE(out_ISSUE_OUT_VAL [i], internal_ISSUE_OUT_VAL [i]);
+        }
+    }
 
     log_end(Issue_queue,FUNCTION);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_transition.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_transition.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Issue_queue_transition.cpp	(revision 110)
@@ -32,4 +32,5 @@
 	for (uint32_t i=0; i<_param->_nb_bank; i++)
 	  _issue_queue [i].clear();
+        _reexecute_queue.clear();
       }
     else
@@ -42,123 +43,118 @@
 	// =====[ ISSUE_IN ]==================================================
 	// ===================================================================
+
 	for (uint32_t i=0; i<_param->_nb_bank; i++)
 	  if (internal_BANK_IN_ACK [i])
 	    {
-	      entry_t * entry = NULL;
-
-	      if (internal_BANK_IN_IS_REEXECUTE [i])
-		{
-		  uint32_t y = internal_BANK_IN_NUM_INST [i];
-	      
-		  if (PORT_READ(in_REEXECUTE_VAL [y]))
-		    {
-                      log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d] - Transaction with REEXECUTE [%d]",i,y);
+              uint32_t x = internal_BANK_IN_NUM_RENAME_UNIT [i];
+              uint32_t y = internal_BANK_IN_NUM_INST [i];
+              
+              if (PORT_READ(in_ISSUE_IN_VAL[x][y]))
+                {
+                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d] - Transaction with ISSUE_IN [%d][%d]",i,x,y);
+
 #ifdef STATISTICS
-                      if (usage_is_set(_usage,USE_STATISTICS))
-                        (*_stat_nb_inst_reexecute) ++;
-#endif
-		      entry = new entry_t
-			(
-			 (_param->_have_port_context_id    )?PORT_READ(in_REEXECUTE_CONTEXT_ID            [y]):0,
-			 (_param->_have_port_front_end_id  )?PORT_READ(in_REEXECUTE_FRONT_END_ID          [y]):0,
-			 (_param->_have_port_rob_ptr       )?PORT_READ(in_REEXECUTE_PACKET_ID             [y]):0,
-			                                     PORT_READ(in_REEXECUTE_OPERATION             [y]),
-			                                     PORT_READ(in_REEXECUTE_TYPE                  [y]),
-			                                     PORT_READ(in_REEXECUTE_STORE_QUEUE_PTR_WRITE [y]),
-			 (_param->_have_port_load_queue_ptr)?PORT_READ(in_REEXECUTE_LOAD_QUEUE_PTR_WRITE  [y]):0,
-			                                     PORT_READ(in_REEXECUTE_HAS_IMMEDIAT          [y]),
-			                                     PORT_READ(in_REEXECUTE_IMMEDIAT              [y]),
-			                                     PORT_READ(in_REEXECUTE_READ_RA               [y]),
-			                                     PORT_READ(in_REEXECUTE_NUM_REG_RA            [y]),
-			                                     PORT_READ(in_REEXECUTE_READ_RB               [y]),
-			                                     PORT_READ(in_REEXECUTE_NUM_REG_RB            [y]),
-			                                     PORT_READ(in_REEXECUTE_READ_RC               [y]),
-			                                     PORT_READ(in_REEXECUTE_NUM_REG_RC            [y]),
-			                                     PORT_READ(in_REEXECUTE_WRITE_RD              [y]),
-			                                     PORT_READ(in_REEXECUTE_NUM_REG_RD            [y]),
-			                                     PORT_READ(in_REEXECUTE_WRITE_RE              [y]),
-			                                     PORT_READ(in_REEXECUTE_NUM_REG_RE            [y])
-			 );
-		    }
-		}
-	      else
-		{
-		  uint32_t x = internal_BANK_IN_NUM_RENAME_UNIT [i];
-		  uint32_t y = internal_BANK_IN_NUM_INST [i];
-
-		  if (PORT_READ(in_ISSUE_IN_VAL[x][y]))
-		    {
-                      log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_IN [%d] - Transaction with ISSUE_IN [%d][%d]",i,x,y);
-
+                  if (usage_is_set(_usage,USE_STATISTICS))
+                    (*_stat_nb_inst_issue_in [x]) ++;
+#endif
+                  entry_t * entry = new entry_t
+                    (
+                     (_param->_have_port_context_id    )?PORT_READ(in_ISSUE_IN_CONTEXT_ID            [x][y]):0,
+                     (_param->_have_port_front_end_id  )?PORT_READ(in_ISSUE_IN_FRONT_END_ID          [x][y]):0,
+                     (_param->_have_port_rob_ptr       )?PORT_READ(in_ISSUE_IN_PACKET_ID             [x][y]):0,
+			                                 PORT_READ(in_ISSUE_IN_OPERATION             [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_TYPE                  [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_STORE_QUEUE_PTR_WRITE [x][y]),
+                     (_param->_have_port_load_queue_ptr)?PORT_READ(in_ISSUE_IN_LOAD_QUEUE_PTR_WRITE  [x][y]):0,
+			                                 PORT_READ(in_ISSUE_IN_HAS_IMMEDIAT          [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_IMMEDIAT              [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_READ_RA               [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_NUM_REG_RA            [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_READ_RB               [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_NUM_REG_RB            [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_READ_RC               [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_NUM_REG_RC            [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_WRITE_RD              [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_NUM_REG_RD            [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_WRITE_RE              [x][y]),
+			                                 PORT_READ(in_ISSUE_IN_NUM_REG_RE            [x][y])
+                     );
+
+                  _issue_queue [i].push_back(entry);
+                }
+	    }
+
+	// ===================================================================
+	// =====[ REEXECUTE_UNIT ]============================================
+	// ===================================================================
+
+        for (uint32_t i=0; i<_param->_nb_inst_reexecute; ++i)
+          if (PORT_READ(in_REEXECUTE_VAL [i]) and internal_REEXECUTE_ACK [i])
+            {
+              log_printf(TRACE,Issue_queue,FUNCTION,"  * REEXECUTE [%d]",i);
 #ifdef STATISTICS
-                      if (usage_is_set(_usage,USE_STATISTICS))
-                        (*_stat_nb_inst_issue_in [x]) ++;
-#endif
-		      entry = new entry_t
-			(
-			 (_param->_have_port_context_id    )?PORT_READ(in_ISSUE_IN_CONTEXT_ID            [x][y]):0,
-			 (_param->_have_port_front_end_id  )?PORT_READ(in_ISSUE_IN_FRONT_END_ID          [x][y]):0,
-			 (_param->_have_port_rob_ptr       )?PORT_READ(in_ISSUE_IN_PACKET_ID             [x][y]):0,
-			                                     PORT_READ(in_ISSUE_IN_OPERATION             [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_TYPE                  [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_STORE_QUEUE_PTR_WRITE [x][y]),
-			 (_param->_have_port_load_queue_ptr)?PORT_READ(in_ISSUE_IN_LOAD_QUEUE_PTR_WRITE  [x][y]):0,
-			                                     PORT_READ(in_ISSUE_IN_HAS_IMMEDIAT          [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_IMMEDIAT              [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_READ_RA               [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_NUM_REG_RA            [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_READ_RB               [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_NUM_REG_RB            [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_READ_RC               [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_NUM_REG_RC            [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_WRITE_RD              [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_NUM_REG_RD            [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_WRITE_RE              [x][y]),
-			                                     PORT_READ(in_ISSUE_IN_NUM_REG_RE            [x][y])
-			 );
-		    }
-		}
-
-	      if (entry != NULL)
-		_issue_queue [i].push_back(entry);
-	    }
+              if (usage_is_set(_usage,USE_STATISTICS))
+                (*_stat_nb_inst_reexecute) ++;
+#endif
+              entry_t * entry = new entry_t
+                (
+                 (_param->_have_port_context_id    )?PORT_READ(in_REEXECUTE_CONTEXT_ID            [i]):0,
+                 (_param->_have_port_front_end_id  )?PORT_READ(in_REEXECUTE_FRONT_END_ID          [i]):0,
+                 (_param->_have_port_rob_ptr       )?PORT_READ(in_REEXECUTE_PACKET_ID             [i]):0,
+			                             PORT_READ(in_REEXECUTE_OPERATION             [i]),
+			                             PORT_READ(in_REEXECUTE_TYPE                  [i]),
+			                             PORT_READ(in_REEXECUTE_STORE_QUEUE_PTR_WRITE [i]),
+                 (_param->_have_port_load_queue_ptr)?PORT_READ(in_REEXECUTE_LOAD_QUEUE_PTR_WRITE  [i]):0,
+			                             PORT_READ(in_REEXECUTE_HAS_IMMEDIAT          [i]),
+			                             PORT_READ(in_REEXECUTE_IMMEDIAT              [i]),
+			                             PORT_READ(in_REEXECUTE_READ_RA               [i]),
+			                             PORT_READ(in_REEXECUTE_NUM_REG_RA            [i]),
+			                             PORT_READ(in_REEXECUTE_READ_RB               [i]),
+			                             PORT_READ(in_REEXECUTE_NUM_REG_RB            [i]),
+			                             PORT_READ(in_REEXECUTE_READ_RC               [i]),
+			                             PORT_READ(in_REEXECUTE_NUM_REG_RC            [i]),
+			                             PORT_READ(in_REEXECUTE_WRITE_RD              [i]),
+			                             PORT_READ(in_REEXECUTE_NUM_REG_RD            [i]),
+			                             PORT_READ(in_REEXECUTE_WRITE_RE              [i]),
+			                             PORT_READ(in_REEXECUTE_NUM_REG_RE            [i])
+                 );
+
+              _reexecute_queue.push_back(entry);
+            }
 
 	// ===================================================================
 	// =====[ ISSUE_OUT ]=================================================
 	// ===================================================================
-	for (uint32_t i=0; i<_param->_nb_bank; i++)
-	  {
-// 	    log_printf(TRACE,Issue_queue,FUNCTION,"  * internal_BANK_OUT [%d] val %d, num_inst %d",i,internal_BANK_OUT_VAL [i],internal_BANK_OUT_NUM_INST [i]);
-
-	    if (internal_BANK_OUT_VAL [i])
-	      {
-#ifdef STATISTICS
-                if (usage_is_set(_usage,USE_STATISTICS))
-                  (*_stat_nb_inst_issue_out) ++;
-#endif
-
-		uint32_t x = internal_BANK_OUT_NUM_INST [i];
-// 		log_printf(TRACE,Issue_queue,FUNCTION,"    * ISSUE_OUT_ACK : %d",PORT_READ(in_ISSUE_OUT_ACK [x]));
-		
-		if (PORT_READ(in_ISSUE_OUT_ACK [x]))
-		  {
-                    log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - Transaction with ISSUE_OUT [%d]",i,x);
-
-
-		    entry_t * entry =  _issue_queue [i].front();
-		    _issue_queue [i].pop_front();
-		    delete entry;
-		  }
-	      }
-	  }
+
+        for (uint32_t i=0; i<_param->_nb_inst_issue; ++i)
+          if (internal_ISSUE_OUT_VAL [i] and PORT_READ(in_ISSUE_OUT_ACK [i]))
+            {
+              entry_t * entry    = internal_ISSUE_OUT_ENTRY    [i];
+
+              if (internal_ISSUE_OUT_FROM_REEXECUTE [i])
+                {
+                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - From Reexecute_queue",i);
+                  
+                  _reexecute_queue.remove(entry);
+                }
+              else
+                {
+                  // front ...
+                  uint32_t  num_bank = internal_ISSUE_OUT_NUM_BANK [i];
+
+                  log_printf(TRACE,Issue_queue,FUNCTION,"  * ISSUE_OUT [%d] - From issue_queue [%d]",i,num_bank);
+
+                  _issue_queue [num_bank].remove(entry);
+                }
+
+              delete entry;
+            } 
       }
 
+#if defined(DEBUG) and defined(DEBUG_Issue_queue) and (DEBUG >= DEBUG_TRACE)
     log_printf(TRACE,Issue_queue,FUNCTION,"  * Dump Issue_queue");
+
     for (uint32_t i=0; i<_param->_nb_bank; i++)
       {
-#ifdef STATISTICS
-        if (usage_is_set(_usage,USE_STATISTICS))
-          *(_stat_bank_nb_inst [i]) += _issue_queue[i].size();
-#endif
 	log_printf(TRACE,Issue_queue,FUNCTION,"    * Bank [%d] size : %d",i,(int)_issue_queue[i].size());
 
@@ -199,6 +195,53 @@
                 ++j;
               }
-
       }
+
+    {
+      log_printf(TRACE,Issue_queue,FUNCTION,"    * Reexecute_queue - size : %d",(int)_reexecute_queue.size());
+      
+      uint32_t i = 0;
+
+      for (std::list<entry_t*>::iterator it=_reexecute_queue.begin();it!=_reexecute_queue.end(); ++it)
+        {
+          log_printf(TRACE,Issue_queue,FUNCTION,"      [%.4d] %.2d %.2d %.4d, %.2d %.3d, %.2d %.2d, %.1d %.8x, %.1d %.4d, %.1d %.4d, %.1d %.4d, %.1d %.4d, %.1d %.4d",
+                     i,
+                     
+                     (*it)->_context_id           ,
+                     (*it)->_front_end_id         ,
+                     (*it)->_packet_id            ,
+                     
+                     (*it)->_type                 ,
+                     (*it)->_operation            ,
+                     
+                     (*it)->_store_queue_ptr_write,
+                     (*it)->_load_queue_ptr_write ,
+                     
+                     (*it)->_has_immediat         ,
+                     (*it)->_immediat             ,
+                     
+                     (*it)->_read_ra              ,
+                     (*it)->_num_reg_ra           ,
+                     
+                     (*it)->_read_rb              ,
+                     (*it)->_num_reg_rb           ,
+                     
+                     (*it)->_read_rc              ,
+                     (*it)->_num_reg_rc           ,
+                     
+                     (*it)->_write_rd             ,
+                     (*it)->_num_reg_rd           ,
+                     
+                     (*it)->_write_re             ,
+                     (*it)->_num_reg_re           );
+          ++i;
+        }
+    }
+#endif
+
+#ifdef STATISTICS
+    if (usage_is_set(_usage,USE_STATISTICS))
+      for (uint32_t i=0; i<_param->_nb_bank; i++)
+        *(_stat_bank_nb_inst [i]) += _issue_queue[i].size();
+#endif
 
 #if defined(STATISTICS) or defined(VHDL_TESTBENCH)
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Parameters.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Parameters.cpp	(revision 109)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Issue_queue/src/Parameters.cpp	(revision 110)
@@ -56,4 +56,5 @@
     _table_routing            = table_routing        ;
     _table_issue_type         = table_issue_type     ;
+    _size_reexecute_queue     = nb_inst_reexecute    ;
 
     log_printf(TRACE,Issue_queue,FUNCTION,"  * table_routing [nb_rename_unit][nb_inst_issue]");
@@ -70,5 +71,4 @@
     
     _max_nb_inst_rename       = max<uint32_t>(_nb_inst_rename,_nb_rename_unit);
-    _nb_bank_select_out       = _nb_bank/nb_inst_issue;
 
     _size_bank                = _size_queue / _nb_bank;
