Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters.cpp	(revision 137)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters.cpp	(revision 138)
@@ -67,4 +67,15 @@
   }
 
+#undef  FUNCTION
+#define FUNCTION "Core::sort_and_unique"
+  //template <typename T>
+  std::vector<uint32_t> sort_and_unique (std::vector<uint32_t> v)
+  {
+    sort (v.begin(), v.end());
+    std::vector<uint32_t>::iterator it=std::unique(v.begin(), v.end());
+    v.erase(it,v.end());
+
+    return v;
+  }
 
 #undef  FUNCTION
@@ -112,4 +123,5 @@
   // Read bloc
   uint32_t                nb_read_bloc                                  ,//
+  uint32_t              * nb_inst_read                                  ,//[nb_read_bloc]
   uint32_t              * size_read_queue                               ,//[nb_read_bloc]
   uint32_t              * size_reservation_station                      ,//[nb_read_bloc]
@@ -118,4 +130,5 @@
   // Write bloc
   uint32_t                nb_write_bloc                                 ,//
+  uint32_t              * nb_inst_write                                 ,//[nb_write_bloc]
   uint32_t              * size_write_queue                              ,//[nb_write_bloc]
   uint32_t              * size_execute_queue                            ,//[nb_write_bloc]
@@ -128,7 +141,12 @@
   uint32_t              * size_load_queue                               ,//[nb_load_store_unit]
   uint32_t              * size_speculative_access_queue                 ,//[nb_load_store_unit]
+  uint32_t              * nb_store_queue_bank                           ,//[nb_load_store_unit]
+  uint32_t              * nb_load_queue_bank                            ,//[nb_load_store_unit]
   uint32_t              * nb_port_check                                 ,//[nb_load_store_unit]
   multi_execute_loop::execute_loop::Tspeculative_load_t  
                         * speculative_load                              ,//[nb_load_store_unit]
+  Tpredictor_t          * speculative_commit_predictor_scheme           ,//[nb_load_store_unit]
+  uint32_t             ** lsu_pht_size_counter                          ,//[nb_load_store_unit][1]
+  uint32_t             ** lsu_pht_nb_counter                            ,//[nb_load_store_unit][1]
   uint32_t              * nb_bypass_memory                              ,//[nb_load_store_unit]
   uint32_t              * nb_cache_port                                 ,//[nb_load_store_unit]
@@ -174,5 +192,5 @@
   uint32_t                nb_ooo_engine                                 ,
   uint32_t              * nb_rename_unit                                ,//[nb_ooo_engine]
-  uint32_t              * nb_inst_issue_slot                            ,//[nb_ooo_engine]
+//uint32_t              * nb_inst_issue_slot                            ,//[nb_ooo_engine]
   uint32_t              * nb_inst_reexecute                             ,//[nb_ooo_engine]
   uint32_t              * nb_inst_commit                                ,//[nb_ooo_engine]
@@ -182,4 +200,6 @@
   uint32_t              * size_re_order_buffer                          ,//[nb_ooo_engine]
   uint32_t              * nb_re_order_buffer_bank                       ,//[nb_ooo_engine]
+  multi_ooo_engine::ooo_engine::commit_unit::Tretire_ooo_scheme_t
+                        * retire_ooo_scheme                             ,//[nb_ooo_engine]
   Tpriority_t           * commit_priority                               ,//[nb_ooo_engine]
   Tload_balancing_t     * commit_load_balancing                         ,//[nb_ooo_engine]
@@ -191,6 +211,4 @@
   Tload_balancing_t     * issue_load_balancing                          ,//[nb_ooo_engine]
   uint32_t              * size_reexecute_queue                          ,//[nb_ooo_engine]
-  Tpriority_t           * reexecute_priority                            ,//[nb_ooo_engine]
-  Tload_balancing_t     * reexecute_load_balancing                      ,//[nb_ooo_engine]
 
   //Execute_loop
@@ -218,8 +236,8 @@
   uint32_t              * link_decod_bloc_with_thread                   ,//[nb_thread]
   uint32_t              * link_rename_bloc_with_front_end               ,//[nb_front_end]
-  bool                *** table_dispatch                                ,//[nb_ooo_engine][nb_inst_issue_slot][nb_read_bloc]
-  bool                 ** link_read_bloc_and_load_store_unit            ,//[nb_read_bloc][nb_load_store_unit]
+//bool                *** table_dispatch                                ,//[nb_ooo_engine][nb_inst_issue_slot][nb_read_bloc]
+  uint32_t              * link_read_bloc_with_load_store_unit           ,//[nb_load_store_unit]
   bool                 ** link_read_bloc_and_functionnal_unit           ,//[nb_read_bloc][nb_functionnal_unit]
-  bool                 ** link_write_bloc_and_load_store_unit           ,//[nb_write_bloc][nb_load_store_unit]
+  uint32_t              * link_write_bloc_with_load_store_unit          ,//[nb_load_store_unit]
   bool                 ** link_write_bloc_and_functionnal_unit          ,//[nb_write_bloc][nb_functionnal_unit]
   uint32_t              * link_load_store_unit_with_thread              ,//[nb_thread]
@@ -268,4 +286,5 @@
 
     _nb_read_bloc                            = nb_read_bloc                            ;
+    _nb_inst_read                            = nb_inst_read                            ;
     _size_read_queue                         = size_read_queue                         ;
     _size_reservation_station                = size_reservation_station                ;
@@ -273,4 +292,5 @@
 
     _nb_write_bloc                           = nb_write_bloc                           ;
+    _nb_inst_write                           = nb_inst_write                           ;
     _size_write_queue                        = size_write_queue                        ;
     _size_execute_queue                      = size_execute_queue                      ;
@@ -282,6 +302,11 @@
     _size_load_queue                         = size_load_queue                         ;
     _size_speculative_access_queue           = size_speculative_access_queue           ;
+    _nb_store_queue_bank                     = nb_store_queue_bank                     ;
+    _nb_load_queue_bank                      = nb_load_queue_bank                      ;
     _nb_port_check                           = nb_port_check                           ;
     _speculative_load                        = speculative_load                        ;
+    _speculative_commit_predictor_scheme     = speculative_commit_predictor_scheme     ;
+    _lsu_pht_size_counter                    = lsu_pht_size_counter                    ;
+    _lsu_pht_nb_counter                      = lsu_pht_nb_counter                      ;
     _nb_bypass_memory                        = nb_bypass_memory                        ;
     _nb_cache_port                           = nb_cache_port                           ;
@@ -321,5 +346,5 @@
     _nb_ooo_engine                           = nb_ooo_engine                           ;
     _nb_rename_unit                          = nb_rename_unit                          ;
-    _nb_inst_issue_slot                      = nb_inst_issue_slot                      ;
+//  _nb_inst_issue_slot                      = nb_inst_issue_slot                      ;
     _nb_inst_reexecute                       = nb_inst_reexecute                       ;
     _nb_inst_commit                          = nb_inst_commit                          ;
@@ -329,4 +354,5 @@
     _size_re_order_buffer                    = size_re_order_buffer                    ;
     _nb_re_order_buffer_bank                 = nb_re_order_buffer_bank                 ;
+    _retire_ooo_scheme                       = retire_ooo_scheme                       ;
     _commit_priority                         = commit_priority                         ;
     _commit_load_balancing                   = commit_load_balancing                   ;
@@ -337,6 +363,4 @@
     _issue_load_balancing                    = issue_load_balancing                    ;
     _size_reexecute_queue                    = size_reexecute_queue                    ;
-    _reexecute_priority                      = reexecute_priority                      ;
-    _reexecute_load_balancing                = reexecute_load_balancing                ;
 
     _nb_execute_loop                         = nb_execute_loop                         ;
@@ -362,8 +386,8 @@
     _link_decod_bloc_with_thread             = link_decod_bloc_with_thread             ;
     _link_rename_bloc_with_front_end         = link_rename_bloc_with_front_end         ;
-    _table_dispatch                          = table_dispatch                          ;
-    _link_read_bloc_and_load_store_unit      = link_read_bloc_and_load_store_unit      ;
+//  _table_dispatch                          = table_dispatch                          ;
+    _link_read_bloc_with_load_store_unit     = link_read_bloc_with_load_store_unit     ;
     _link_read_bloc_and_functionnal_unit     = link_read_bloc_and_functionnal_unit     ;
-    _link_write_bloc_and_load_store_unit     = link_write_bloc_and_load_store_unit     ;
+    _link_write_bloc_with_load_store_unit    = link_write_bloc_with_load_store_unit    ;
     _link_write_bloc_and_functionnal_unit    = link_write_bloc_and_functionnal_unit    ;
     _link_load_store_unit_with_thread        = link_load_store_unit_with_thread        ;
@@ -885,35 +909,70 @@
 
     {
-      std::vector<uint32_t> list_execute_loop [_nb_ooo_engine];
-
       // initialization counter
       for (uint32_t i=0; i<_nb_ooo_engine; ++i)
         _ooo_engine_nb_execute_loop [i] = 0;
-
-      // scan the dispatch table
+            
+      std::vector<uint32_t> list_execute_loop [_nb_ooo_engine];
+
+      for (uint32_t i=0; i<_nb_thread; ++i)
+        {
+          uint32_t num_front_end    = _link_context_with_thread [i].first;
+          uint32_t num_rename_bloc  = _link_rename_bloc_with_front_end [num_front_end];
+          uint32_t num_ooo_engine   = _link_rename_unit_with_rename_bloc [num_rename_bloc].first;
+          uint32_t num_execute_loop = _link_execute_unit_with_load_store_unit [i].first;
+          list_execute_loop[num_ooo_engine].push_back(num_execute_loop);
+
+          // One execute per ooo_engine
+          // for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
+          //   if (_link_thread_and_functionnal_unit [i][j])
+          //     {
+          //       uint32_t num_execute_loop = _link_execute_unit_with_functionnal_unit [i].first;
+          //       list_execute_loop[num_ooo_engine].push_back(num_execute_loop);
+          //     }
+        }
+
+      // Sort and erase duplicate value
       for (uint32_t i=0; i<_nb_ooo_engine; ++i)
         {
-          for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-            for (uint32_t k=0; k<_nb_read_bloc; ++k)
-              {
-                // have route between this slot's ooo_engine and an read_bloc
-                if (_table_dispatch [i][j][k])
-                  {
-                    uint32_t num_execute_loop = _link_read_unit_with_read_bloc [k].first;
-                    
-                    list_execute_loop[i].push_back(num_execute_loop);
-                  }
-              }
-                
-          {
-            sort  (list_execute_loop[i].begin(),
-                   list_execute_loop[i].end());
-            std::vector<uint32_t>::iterator it=std::unique(list_execute_loop[i].begin(),
-                                                           list_execute_loop[i].end());
-            list_execute_loop[i].erase(it,list_execute_loop[i].end());
-          }
-
+          list_execute_loop[i] = sort_and_unique (list_execute_loop[i]);
+
+          // {
+          //   sort  (list_execute_loop[i].begin(),
+          //          list_execute_loop[i].end());
+          //   std::vector<uint32_t>::iterator it=std::unique(list_execute_loop[i].begin(),
+          //                                                  list_execute_loop[i].end());
+          //   list_execute_loop[i].erase(it,list_execute_loop[i].end());
+          // }
+          
           _ooo_engine_nb_execute_loop [i] = list_execute_loop[i].size();
         }
+
+#if 0
+      // // scan the dispatch table
+      // for (uint32_t i=0; i<_nb_ooo_engine; ++i)
+      //   {
+      //     for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
+      //       for (uint32_t k=0; k<_nb_read_bloc; ++k)
+      //         {
+      //           // have route between this slot's ooo_engine and an read_bloc
+      //           if (_table_dispatch [i][j][k])
+      //             {
+      //               uint32_t num_execute_loop = _link_read_unit_with_read_bloc [k].first;
+                    
+      //               list_execute_loop[i].push_back(num_execute_loop);
+      //             }
+      //         }
+                
+      //     {
+      //       sort  (list_execute_loop[i].begin(),
+      //              list_execute_loop[i].end());
+      //       std::vector<uint32_t>::iterator it=std::unique(list_execute_loop[i].begin(),
+      //                                                      list_execute_loop[i].end());
+      //       list_execute_loop[i].erase(it,list_execute_loop[i].end());
+      //     }
+
+      //     _ooo_engine_nb_execute_loop [i] = list_execute_loop[i].size();
+      //   }
+#endif
 
       log_printf(TRACE,Core,FUNCTION,_("  * translate_ooo_engine_num_execute_loop"));
@@ -1029,5 +1088,5 @@
       }
     
-    ALLOC4(_network_table_dispatch                        ,bool             ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_execute_loop,_nb_read_unit[it3]);
+//  ALLOC4(_network_table_dispatch                        ,bool             ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_execute_loop,_nb_read_unit[it3]);
 //  ALLOC3(_ooo_engine_table_routing                      ,bool             ,_nb_ooo_engine,_nb_rename_unit[it1],_nb_inst_issue_slot[it1]);
 //  ALLOC3(_ooo_engine_table_issue_type                   ,bool             ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_type);
@@ -1035,105 +1094,141 @@
     ALLOC2(_list_load_store_unit_with_rename_unit         ,std::vector<uint32_t>,_nb_ooo_engine,_nb_rename_unit[it1]);
 
+    for (uint32_t num_thread=0; num_thread<_nb_thread; ++num_thread)
+      {
+        uint32_t num_front_end    = _link_context_with_thread [num_thread].first;
+        uint32_t num_rename_bloc  = _link_rename_bloc_with_front_end [num_front_end];
+        uint32_t num_ooo_engine   = _link_rename_unit_with_rename_bloc [num_rename_bloc].first;
+        uint32_t num_rename_unit  = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
+        
+        {
+          uint32_t num_load_store_unit = _link_load_store_unit_with_thread [num_thread];
+          
+          log_printf(TRACE,Core,FUNCTION,_("  * list_load_store_unit_with_rename_unit [%d][%d] = %d"),
+                     num_ooo_engine,
+                     num_rename_unit,
+                     num_load_store_unit);
+          
+          _list_load_store_unit_with_rename_unit [num_ooo_engine][num_rename_unit].push_back(num_load_store_unit);
+        }
+        
+        for (uint32_t num_functionnal_unit=0;
+             num_functionnal_unit<_nb_functionnal_unit;
+             ++num_functionnal_unit)
+          if (_link_thread_and_functionnal_unit[num_thread][num_functionnal_unit])
+            {
+              log_printf(TRACE,Core,FUNCTION,_("  * list_functionnal_unit_with_rename_unit [%d][%d] = %d"),
+                         num_ooo_engine,
+                         num_rename_unit,
+                         num_functionnal_unit);
+              
+              _list_functionnal_unit_with_rename_unit [num_ooo_engine][num_rename_unit].push_back(num_functionnal_unit);
+            }
+      }
+
     for (uint32_t i=0; i<_nb_ooo_engine; ++i)
       {
-//         log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_table_issue_type [%d]"),i);
-
-        // Init
-        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-          {
-            for (uint32_t k=0; k<_nb_execute_loop; ++k)
-              for (uint32_t l=0; l<_nb_read_unit[k]; ++l)
-                _network_table_dispatch [i][j][k][l] = false;
-//             for (uint32_t k=0; k<_nb_rename_unit[i]; ++k)
-//               _ooo_engine_table_routing [i][k][j] = false;
-//             for (uint32_t k=0; k<_nb_type; ++k)
-//               _ooo_engine_table_issue_type [i][j][k] = false;
-          }
-
-        std::vector<uint32_t> list_thread_with_inst_issue [_nb_inst_issue_slot[i]];
+#if 0
+// //         log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_table_issue_type [%d]"),i);
+
+//         // Init
+//         for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
+//           {
+//             for (uint32_t k=0; k<_nb_execute_loop; ++k)
+//               for (uint32_t l=0; l<_nb_read_unit[k]; ++l)
+//                 _network_table_dispatch [i][j][k][l] = false;
+//             // for (uint32_t k=0; k<_nb_rename_unit[i]; ++k)
+//             //   _ooo_engine_table_routing [i][k][j] = false;
+//             // for (uint32_t k=0; k<_nb_type; ++k)
+//             //   _ooo_engine_table_issue_type [i][j][k] = false;
+//           }
+
+//         std::vector<uint32_t> list_thread_with_inst_issue [_nb_inst_issue_slot[i]];
         
-        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-          {
-            for (uint32_t k=0; k<_nb_read_bloc; ++k)
-              // Test if the issue slot is linked with the read_bloc
-              if (_table_dispatch[i][j][k])
-                {
-                  pair_dual x = _link_read_unit_with_read_bloc[k];
-                  _network_table_dispatch [i][j][x.first][x.second] = true;
-
-                  // Test functional unit connected with this read bloc
-                  for (uint32_t l=0; l<_nb_functionnal_unit; ++l)
-                    {
-                      // the issue slot [j] is connected with the read bloc [k] and it's connected with the functionnal_unit [l]
-                      if (_link_read_bloc_and_functionnal_unit [k][l])
-                        {
-                          // Scan timing table, test if have an instruction
-//                           for (uint32_t m=0; m<_nb_type; ++m)
-//                             for (uint32_t n=0; n<_nb_operation; ++n)
-//                               if (_timing[l][m][n]._latence > 0)
-//                                 {
-//                                   log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> true"),j,m);
+//         for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
+//           {
+//             for (uint32_t k=0; k<_nb_read_bloc; ++k)
+//               // Test if the issue slot is linked with the read_bloc
+//               if (_table_dispatch[i][j][k])
+//                 {
+//                   pair_dual x = _link_read_unit_with_read_bloc[k];
+//                   _network_table_dispatch [i][j][x.first][x.second] = true;
+
+//                   // Test functional unit connected with this read bloc
+//                   for (uint32_t l=0; l<_nb_functionnal_unit; ++l)
+//                     {
+//                       // the issue slot [j] is connected with the read bloc [k] and it's connected with the functionnal_unit [l]
+//                       if (_link_read_bloc_and_functionnal_unit [k][l])
+//                         {
+//                           // Scan timing table, test if have an instruction
+// //                           for (uint32_t m=0; m<_nb_type; ++m)
+// //                             for (uint32_t n=0; n<_nb_operation; ++n)
+// //                               if (_timing[l][m][n]._latence > 0)
+// //                                 {
+// //                                   log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> true"),j,m);
                                   
-//                                   _ooo_engine_table_issue_type [i][j][m] = true;
-//                                   break;
-//                                 }
+// //                                   _ooo_engine_table_issue_type [i][j][m] = true;
+// //                                   break;
+// //                                 }
                           
-                          for (uint32_t m=0; m<_nb_thread; ++m)
-                            {
-                              list_thread_with_inst_issue [j].push_back(m);
+//                           for (uint32_t m=0; m<_nb_thread; ++m)
+//                             {
+//                               list_thread_with_inst_issue [j].push_back(m);
                               
-                              uint32_t num_front_end   = _link_context_with_thread [m].first;
-                              uint32_t num_rename_bloc = _link_rename_bloc_with_front_end[num_front_end];
-                              uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
+//                               uint32_t num_front_end   = _link_context_with_thread [m].first;
+//                               uint32_t num_rename_bloc = _link_rename_bloc_with_front_end[num_front_end];
+//                               uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
                               
-                              _list_functionnal_unit_with_rename_unit [i][num_rename_unit].push_back(l);
-                            }
-                        }
-                    }
-
-                  // Test load store unit connected with this read bloc
-                  for (uint32_t l=0; l<_nb_load_store_unit; ++l)
-                    {
-                      // Test load store unit connected with this read bloc
-                      if (_link_read_bloc_and_load_store_unit [k][l])
-                       {
-//                        _ooo_engine_table_issue_type [i][j][TYPE_MEMORY] = true;
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LBS)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LBS)._type][instruction_information(INSTRUCTION_L_LBS)._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LBZ)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LBZ)._type][instruction_information(INSTRUCTION_L_LBZ)._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LD )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LD )._type][instruction_information(INSTRUCTION_L_LD )._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LHS)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LHS)._type][instruction_information(INSTRUCTION_L_LHS)._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LHZ)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LHZ)._type][instruction_information(INSTRUCTION_L_LHZ)._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LWS)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LWS)._type][instruction_information(INSTRUCTION_L_LWS)._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LWZ)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LWZ)._type][instruction_information(INSTRUCTION_L_LWZ)._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SB )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SB )._type][instruction_information(INSTRUCTION_L_SB )._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SD )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SD )._type][instruction_information(INSTRUCTION_L_SD )._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SH )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SH )._type][instruction_information(INSTRUCTION_L_SH )._operation]._latence > 0);
-//                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SW )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SW )._type][instruction_information(INSTRUCTION_L_SW )._operation]._latence > 0);
-
-                          // the issue slot [j] is connected with the read bloc [k] and it's connected with the load_store_unit [l]
-                          for (uint32_t m=0; m<_nb_thread; ++m)
-                            {
-                              list_thread_with_inst_issue [j].push_back(m);
+//                               _list_functionnal_unit_with_rename_unit [i][num_rename_unit].push_back(l);
+//                             }
+//                         }
+//                     }
+
+//                   // Test load store unit connected with this read bloc
+//                   for (uint32_t l=0; l<_nb_load_store_unit; ++l)
+//                     {
+//                       // Test load store unit connected with this read bloc
+//                       if (_link_read_bloc_and_load_store_unit [k][l])
+//                        {
+// //                        _ooo_engine_table_issue_type [i][j][TYPE_MEMORY] = true;
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LBS)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LBS)._type][instruction_information(INSTRUCTION_L_LBS)._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LBZ)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LBZ)._type][instruction_information(INSTRUCTION_L_LBZ)._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LD )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LD )._type][instruction_information(INSTRUCTION_L_LD )._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LHS)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LHS)._type][instruction_information(INSTRUCTION_L_LHS)._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LHZ)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LHZ)._type][instruction_information(INSTRUCTION_L_LHZ)._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LWS)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LWS)._type][instruction_information(INSTRUCTION_L_LWS)._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_LWZ)._type] |= (_timing[l][instruction_information(INSTRUCTION_L_LWZ)._type][instruction_information(INSTRUCTION_L_LWZ)._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SB )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SB )._type][instruction_information(INSTRUCTION_L_SB )._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SD )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SD )._type][instruction_information(INSTRUCTION_L_SD )._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SH )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SH )._type][instruction_information(INSTRUCTION_L_SH )._operation]._latence > 0);
+// //                        _ooo_engine_table_issue_type [i][j][instruction_information(INSTRUCTION_L_SW )._type] |= (_timing[l][instruction_information(INSTRUCTION_L_SW )._type][instruction_information(INSTRUCTION_L_SW )._operation]._latence > 0);
+
+//                           // the issue slot [j] is connected with the read bloc [k] and it's connected with the load_store_unit [l]
+//                           for (uint32_t m=0; m<_nb_thread; ++m)
+//                             {
+//                               list_thread_with_inst_issue [j].push_back(m);
                               
-                              uint32_t num_front_end   = _link_context_with_thread [m].first;
-                              uint32_t num_rename_bloc = _link_rename_bloc_with_front_end[num_front_end];
-                              uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
+//                               uint32_t num_front_end   = _link_context_with_thread [m].first;
+//                               uint32_t num_rename_bloc = _link_rename_bloc_with_front_end[num_front_end];
+//                               uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
                               
-                              log_printf(TRACE,Core,FUNCTION,_("  * list_load_store_unit_with_rename_unit [%d][%d][%d] = %d"),i,num_rename_unit,_list_load_store_unit_with_rename_unit [i][num_rename_unit].size(),l);
-
-                              _list_load_store_unit_with_rename_unit [i][num_rename_unit].push_back(l);
-                            }
-                        }
-                    }
-                }
-            // sort and erase duplicate value
-            {
-              sort  (list_thread_with_inst_issue [j].begin(),
-                     list_thread_with_inst_issue [j].end());
-              std::vector<uint32_t>::iterator it=unique(list_thread_with_inst_issue [j].begin(),
-                                                        list_thread_with_inst_issue [j].end());
-              list_thread_with_inst_issue [j].erase(it,list_thread_with_inst_issue [j].end());
-            }
-          }
+//                               log_printf(TRACE,Core,FUNCTION,_("  * list_load_store_unit_with_rename_unit [%d][%d][%d] = %d"),i,num_rename_unit,_list_load_store_unit_with_rename_unit [i][num_rename_unit].size(),l);
+
+//                               _list_load_store_unit_with_rename_unit [i][num_rename_unit].push_back(l);
+//                             }
+//                         }
+//                     }
+//                 }
+//             // sort and erase duplicate value
+//             list_thread_with_inst_issue [j] = sort_and_unique (list_thread_with_inst_issue [j]);
+
+//             // {
+//             //   sort  (list_thread_with_inst_issue [j].begin(),
+//             //          list_thread_with_inst_issue [j].end());
+//             //   std::vector<uint32_t>::iterator it=unique(list_thread_with_inst_issue [j].begin(),
+//             //                                             list_thread_with_inst_issue [j].end());
+//             //   list_thread_with_inst_issue [j].erase(it,list_thread_with_inst_issue [j].end());
+//             // }
+//           }
+#endif
 
         log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_table_routing [%d]"),i);
@@ -1141,18 +1236,23 @@
           {
             // sort and erase duplicate value
-            {
-              sort  (_list_load_store_unit_with_rename_unit  [i][j].begin(),
-                     _list_load_store_unit_with_rename_unit  [i][j].end());
-              std::vector<uint32_t>::iterator it=unique(_list_load_store_unit_with_rename_unit  [i][j].begin(),
-                                                        _list_load_store_unit_with_rename_unit  [i][j].end());
-              _list_load_store_unit_with_rename_unit  [i][j].erase(it,_list_load_store_unit_with_rename_unit  [i][j].end());
-            }
-            {
-              sort  (_list_functionnal_unit_with_rename_unit  [i][j].begin(),
-                     _list_functionnal_unit_with_rename_unit  [i][j].end());
-              std::vector<uint32_t>::iterator it=unique(_list_functionnal_unit_with_rename_unit  [i][j].begin(),
-                                                        _list_functionnal_unit_with_rename_unit  [i][j].end());
-              _list_functionnal_unit_with_rename_unit  [i][j].erase(it,_list_functionnal_unit_with_rename_unit  [i][j].end());
-            }
+            _list_load_store_unit_with_rename_unit  [i][j] = sort_and_unique (_list_load_store_unit_with_rename_unit  [i][j]);
+
+            // {
+            //   sort  (_list_load_store_unit_with_rename_unit  [i][j].begin(),
+            //          _list_load_store_unit_with_rename_unit  [i][j].end());
+            //   std::vector<uint32_t>::iterator it=unique(_list_load_store_unit_with_rename_unit  [i][j].begin(),
+            //                                             _list_load_store_unit_with_rename_unit  [i][j].end());
+            //   _list_load_store_unit_with_rename_unit  [i][j].erase(it,_list_load_store_unit_with_rename_unit  [i][j].end());
+            // }
+
+            _list_functionnal_unit_with_rename_unit  [i][j] = sort_and_unique (_list_functionnal_unit_with_rename_unit  [i][j]);
+            
+            // {
+            //   sort  (_list_functionnal_unit_with_rename_unit  [i][j].begin(),
+            //          _list_functionnal_unit_with_rename_unit  [i][j].end());
+            //   std::vector<uint32_t>::iterator it=unique(_list_functionnal_unit_with_rename_unit  [i][j].begin(),
+            //                                             _list_functionnal_unit_with_rename_unit  [i][j].end());
+            //   _list_functionnal_unit_with_rename_unit  [i][j].erase(it,_list_functionnal_unit_with_rename_unit  [i][j].end());
+            // }
 
 //             uint32_t num_rename_bloc = _link_rename_bloc_with_rename_unit[i][j];
@@ -1175,15 +1275,8 @@
       }
     
-    log_printf(TRACE,Core,FUNCTION,_("  * network_table_dispatch [nb_ooo_engine][nb_inst_issue_slot][nb_execute_loop][nb_read_unit]"));
-    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
-      for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-        for (uint32_t k=0; k<_nb_execute_loop; ++k)
-          for (uint32_t l=0; l<_nb_read_unit[k]; ++l)
-            if (_network_table_dispatch [i][j][k][l] == true)
-              log_printf(TRACE,Core,FUNCTION,_("   Issue Slot [%d][%d] is connected with Read_unit [%d][%d]"),i,j,k,l);
-
-    ALLOC3(_network_table_issue_type,bool,_nb_execute_loop,_nb_read_unit[it1],_nb_type);
-
-    log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_type"));
+    ALLOC3(_network_table_issue_type  ,bool,_nb_execute_loop,_nb_read_unit[it1],_nb_type);
+    ALLOC3(_network_table_issue_thread,bool,_nb_execute_loop,_nb_read_unit[it1],_nb_thread);
+
+    log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_type and network_table_issue_thread"));
     for (uint32_t i=0; i<_nb_execute_loop; ++i)
       for (uint32_t j=0; j<_nb_read_unit[i]; ++j)
@@ -1191,5 +1284,7 @@
           // init
           for (uint32_t t=0; t<_nb_type; ++t)
-            _network_table_issue_type [i][j][t] = false;
+            _network_table_issue_type   [i][j][t] = false;
+          for (uint32_t t=0; t<_nb_thread; ++t)
+            _network_table_issue_thread [i][j][t] = false;
 
           // get number of read bloc
@@ -1199,26 +1294,45 @@
           for (uint32_t k=0; k<_nb_functionnal_unit; ++k)
             if (_link_read_bloc_and_functionnal_unit [num_read_bloc][k])
-              // Scan timing table, test if have an instruction
-              for (uint32_t t=0; t<_nb_type; ++t)
-                for (uint32_t o=0; o<_nb_operation; ++o)
-                  if (_timing[k][t][o]._latence > 0)
+              {
+                // Scan timing table, test if have an instruction
+                for (uint32_t t=0; t<_nb_type; ++t)
+                  for (uint32_t o=0; o<_nb_operation; ++o)
+                    if (_timing[k][t][o]._latence > 0)
+                      {
+                        log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_type   [%d][%d][%d] -> true"),i,j,t);
+                        
+                        _network_table_issue_type [i][j][t] = true;
+                        break; // operation
+                      }
+
+                for (uint32_t t=0; t<_nb_thread; ++t)
+                  if (_link_thread_and_functionnal_unit [t][k])
                     {
-                      log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d] -> true"),i,j,t);
+                      log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_thread [%d][%d][%d] -> true"),i,j,t);
                       
-                      _network_table_issue_type [i][j][t] = true;
-                      break; // operation
+                      _network_table_issue_thread [i][j][t] = true;
                     }
+              }
           
           // Test load store unit connected with this read bloc
           for (uint32_t k=0; k<_nb_load_store_unit; ++k)
             // Test load store unit connected with this read bloc
-            if (_link_read_bloc_and_load_store_unit [num_read_bloc][k])
+            if (_link_read_bloc_with_load_store_unit [k] == num_read_bloc)
               {
-                uint32_t t = TYPE_MEMORY;
-                
-                log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d] -> true"),i,j,t);
-                
-                _network_table_issue_type [i][j][t] = true;
-                break; // load_store_unit
+                {
+                  uint32_t t = TYPE_MEMORY;
+                  
+                  log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_type   [%d][%d][%d] -> true"),i,j,t);
+                  
+                  _network_table_issue_type [i][j][t] = true;
+                }
+
+                for (uint32_t t=0; t<_nb_thread; ++t)
+                  if (_link_load_store_unit_with_thread[t] == k)
+                    {
+                      log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_thread [%d][%d][%d] -> true"),i,j,t);
+                      
+                      _network_table_issue_thread [i][j][t] = true;
+                    }
               }
         }
@@ -1346,5 +1460,5 @@
     ALLOC1(_list_ooo_engine_with_execute_loop                      ,std::vector<uint32_t>,_nb_execute_loop);
     ALLOC1(_list_front_end_with_execute_loop                       ,std::vector<uint32_t>,_nb_execute_loop);
-    
+
     for (uint32_t i=0; i<_nb_ooo_engine; ++i)
       {
@@ -1366,18 +1480,23 @@
     for (uint32_t i=0; i<_nb_execute_loop; ++i)
       {
-        {
-          sort  (_list_ooo_engine_with_execute_loop[i].begin(),
-                 _list_ooo_engine_with_execute_loop[i].end());
-          std::vector<uint32_t>::iterator it=unique(_list_ooo_engine_with_execute_loop[i].begin(),
-                                                    _list_ooo_engine_with_execute_loop[i].end());
-          _list_ooo_engine_with_execute_loop[i].erase(it,_list_ooo_engine_with_execute_loop[i].end());
-        }
-        {
-          sort  (_list_front_end_with_execute_loop[i].begin(),
-                 _list_front_end_with_execute_loop[i].end());
-          std::vector<uint32_t>::iterator it=unique(_list_front_end_with_execute_loop[i].begin(),
-                                                    _list_front_end_with_execute_loop[i].end());
-          _list_front_end_with_execute_loop[i].erase(it,_list_front_end_with_execute_loop[i].end());
-        }
+        _list_ooo_engine_with_execute_loop[i] = sort_and_unique (_list_ooo_engine_with_execute_loop[i]);
+
+        // {
+        //   sort  (_list_ooo_engine_with_execute_loop[i].begin(),
+        //          _list_ooo_engine_with_execute_loop[i].end());
+        //   std::vector<uint32_t>::iterator it=unique(_list_ooo_engine_with_execute_loop[i].begin(),
+        //                                             _list_ooo_engine_with_execute_loop[i].end());
+        //   _list_ooo_engine_with_execute_loop[i].erase(it,_list_ooo_engine_with_execute_loop[i].end());
+        // }
+
+        _list_front_end_with_execute_loop[i] = sort_and_unique (_list_front_end_with_execute_loop[i]);
+
+        // {
+        //   sort  (_list_front_end_with_execute_loop[i].begin(),
+        //          _list_front_end_with_execute_loop[i].end());
+        //   std::vector<uint32_t>::iterator it=unique(_list_front_end_with_execute_loop[i].begin(),
+        //                                             _list_front_end_with_execute_loop[i].end());
+        //   _list_front_end_with_execute_loop[i].erase(it,_list_front_end_with_execute_loop[i].end());
+        // }
       }
 
@@ -1402,5 +1521,5 @@
     ALLOC1(_execute_loop_nb_packet                                 ,uint32_t,_nb_execute_loop);
     ALLOC1(_execute_loop_nb_thread                                 ,uint32_t,_nb_execute_loop);
-    
+
     for (uint32_t i=0; i<_nb_execute_loop; ++i)
       {
@@ -1453,4 +1572,5 @@
         }  
     
+    ALLOC2(_execute_loop_nb_inst_read                              ,uint32_t,_nb_execute_loop,_nb_read_unit[it1]);
     ALLOC2(_execute_loop_size_read_queue                           ,uint32_t,_nb_execute_loop,_nb_read_unit[it1]);
     ALLOC2(_execute_loop_size_reservation_station                  ,uint32_t,_nb_execute_loop,_nb_read_unit[it1]);
@@ -1468,4 +1588,5 @@
             log_printf(TRACE,Core,FUNCTION,_("      * num_read_bloc : %d"),num_read_bloc);
             
+            _execute_loop_nb_inst_read             [i][j] = _nb_inst_read             [num_read_bloc];
             _execute_loop_size_read_queue          [i][j] = _size_read_queue          [num_read_bloc];
             _execute_loop_size_reservation_station [i][j] = _size_reservation_station [num_read_bloc];
@@ -1538,13 +1659,18 @@
       }
     
-    ALLOC2(_execute_loop_size_store_queue                          ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
-    ALLOC2(_execute_loop_size_load_queue                           ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
-    ALLOC2(_execute_loop_size_speculative_access_queue             ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
-    ALLOC2(_execute_loop_nb_port_check                             ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_size_store_queue                          ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_size_load_queue                           ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_size_speculative_access_queue             ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_nb_store_queue_bank                       ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_nb_load_queue_bank                        ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_nb_port_check                             ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     ALLOC2(_execute_loop_speculative_load                          ,multi_execute_loop::execute_loop::Tspeculative_load_t
-                                                                            ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
-    ALLOC2(_execute_loop_nb_bypass_memory                          ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
-    ALLOC2(_execute_loop_nb_cache_port                             ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
-    ALLOC2(_execute_loop_nb_inst_memory                            ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+                                                                                ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_speculative_commit_predictor_scheme       ,Tpredictor_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC3(_execute_loop_lsu_pht_size_counter                      ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],1);
+    ALLOC3(_execute_loop_lsu_pht_nb_counter                        ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],1);
+    ALLOC2(_execute_loop_nb_bypass_memory                          ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_nb_cache_port                             ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    ALLOC2(_execute_loop_nb_inst_memory                            ,uint32_t    ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     
     for (uint32_t i=0; i<_nb_execute_loop; ++i)
@@ -1556,14 +1682,23 @@
           log_printf(TRACE,Core,FUNCTION,_("    * nb_bypass_memory : %d"),_nb_bypass_memory[num_load_store_unit]);
 
-          _execute_loop_size_store_queue              [i][j] = _size_store_queue              [num_load_store_unit];
-          _execute_loop_size_load_queue               [i][j] = _size_load_queue               [num_load_store_unit];
-          _execute_loop_size_speculative_access_queue [i][j] = _size_speculative_access_queue [num_load_store_unit];
-          _execute_loop_nb_port_check                 [i][j] = _nb_port_check                 [num_load_store_unit];
-          _execute_loop_speculative_load              [i][j] = _speculative_load              [num_load_store_unit];
-          _execute_loop_nb_bypass_memory              [i][j] = _nb_bypass_memory              [num_load_store_unit];
-          _execute_loop_nb_cache_port                 [i][j] = _nb_cache_port                 [num_load_store_unit];
-          _execute_loop_nb_inst_memory                [i][j] = _nb_inst_memory                [num_load_store_unit];
+          _execute_loop_size_store_queue                    [i][j] = _size_store_queue                    [num_load_store_unit];
+          _execute_loop_size_load_queue                     [i][j] = _size_load_queue                     [num_load_store_unit];
+          _execute_loop_size_speculative_access_queue       [i][j] = _size_speculative_access_queue       [num_load_store_unit];
+          _execute_loop_nb_store_queue_bank                 [i][j] = _nb_store_queue_bank                 [num_load_store_unit];
+          _execute_loop_nb_load_queue_bank                  [i][j] = _nb_load_queue_bank                  [num_load_store_unit];
+          _execute_loop_nb_port_check                       [i][j] = _nb_port_check                       [num_load_store_unit];
+          _execute_loop_speculative_load                    [i][j] = _speculative_load                    [num_load_store_unit];
+          _execute_loop_speculative_commit_predictor_scheme [i][j] = _speculative_commit_predictor_scheme [num_load_store_unit];
+          for (uint32_t k=0; k<1; ++k)
+            {
+          _execute_loop_lsu_pht_size_counter             [i][j][k] = _lsu_pht_size_counter                [num_load_store_unit][k];
+          _execute_loop_lsu_pht_nb_counter               [i][j][k] = _lsu_pht_nb_counter                  [num_load_store_unit][k];
+            }
+          _execute_loop_nb_bypass_memory                    [i][j] = _nb_bypass_memory                    [num_load_store_unit];
+          _execute_loop_nb_cache_port                       [i][j] = _nb_cache_port                       [num_load_store_unit];
+          _execute_loop_nb_inst_memory                      [i][j] = _nb_inst_memory                      [num_load_store_unit];
         }
 
+    ALLOC2(_execute_loop_nb_inst_write                             ,uint32_t,_nb_execute_loop,_nb_write_unit[it1]);
     ALLOC2(_execute_loop_size_write_queue                          ,uint32_t,_nb_execute_loop,_nb_write_unit[it1]);
     ALLOC2(_execute_loop_size_execute_queue                        ,uint32_t,_nb_execute_loop,_nb_write_unit[it1]);
@@ -1576,4 +1711,5 @@
           uint32_t num_write_bloc = _link_write_bloc_with_write_unit [i][j];
     
+          _execute_loop_nb_inst_write      [i][j] = _nb_inst_write      [num_write_bloc];
           _execute_loop_size_write_queue   [i][j] = _size_write_queue   [num_write_bloc];
           _execute_loop_size_execute_queue [i][j] = _size_execute_queue [num_write_bloc];
@@ -1660,5 +1796,5 @@
               
               if (is_lsu)
-                link = _link_read_bloc_and_load_store_unit  [num_read_bloc][num_load_store_unit];
+                link = (_link_read_bloc_with_load_store_unit [num_load_store_unit] == num_read_bloc);
               else
                 link = _link_read_bloc_and_functionnal_unit [num_read_bloc][num_functionnal_unit];
@@ -1689,5 +1825,5 @@
               
               if (is_lsu)
-                link = _link_write_bloc_and_load_store_unit  [num_write_bloc][num_load_store_unit];
+                link = (_link_write_bloc_with_load_store_unit [num_load_store_unit] == num_write_bloc);
               else
                 link = _link_write_bloc_and_functionnal_unit [num_write_bloc][num_functionnal_unit];
@@ -1745,5 +1881,5 @@
               {
                 uint32_t num_write_bloc = _link_write_bloc_with_write_unit[i][k];
-                bool     have_link = (is_lsu)?(_link_write_bloc_and_load_store_unit [num_write_bloc][num_load_store_unit]):(_link_write_bloc_and_functionnal_unit [num_write_bloc][num_functionnal_unit]);
+                bool     have_link = (is_lsu)?(_link_write_bloc_with_load_store_unit [num_load_store_unit]==num_write_bloc):(_link_write_bloc_and_functionnal_unit [num_write_bloc][num_functionnal_unit]);
                   
                 if (have_link)
@@ -1997,5 +2133,5 @@
        _ooo_engine_nb_inst_insert                    [i],
        _ooo_engine_nb_inst_retire                    [i],
-//        _nb_inst_issue                                [i],
+//     _nb_inst_issue                                [i],
        _ooo_engine_nb_inst_execute                   [i],
        _nb_inst_reexecute                            [i],
@@ -2011,4 +2147,5 @@
        _size_re_order_buffer                         [i],
        _nb_re_order_buffer_bank                      [i],
+       _retire_ooo_scheme                            [i],
        _commit_priority                              [i],
        _commit_load_balancing                        [i],
@@ -2021,6 +2158,4 @@
 //        _ooo_engine_table_issue_type                  [i],
        _size_reexecute_queue                         [i],
-       _reexecute_priority                           [i],
-       _reexecute_load_balancing                     [i],
        _ooo_engine_rename_select_priority            [i],
        _ooo_engine_rename_select_load_balancing      [i],
@@ -2060,4 +2195,5 @@
          _size_special_data                                          ,
 
+         _execute_loop_nb_inst_read                               [i],
          _execute_loop_size_read_queue                            [i],
          _execute_loop_size_reservation_station                   [i],
@@ -2071,10 +2207,16 @@
          _execute_loop_size_load_queue                            [i],
          _execute_loop_size_speculative_access_queue              [i],
+         _execute_loop_nb_store_queue_bank                        [i],
+         _execute_loop_nb_load_queue_bank                         [i],
          _execute_loop_nb_port_check                              [i],
          _execute_loop_speculative_load                           [i],
+         _execute_loop_speculative_commit_predictor_scheme        [i],
+         _execute_loop_lsu_pht_size_counter                       [i],
+         _execute_loop_lsu_pht_nb_counter                         [i],
          _execute_loop_nb_bypass_memory                           [i],
          _execute_loop_nb_cache_port                              [i],
          _execute_loop_nb_inst_memory                             [i],
 
+         _execute_loop_nb_inst_write                              [i],
          _execute_loop_size_write_queue                           [i],
          _execute_loop_size_execute_queue                         [i],
@@ -2146,37 +2288,39 @@
     _param_glue          = new core::core_glue::Parameters 
       (
-       _nb_front_end                         ,
-       _nb_context                           ,//[nb_front_end]
-       _nb_ooo_engine                        ,
-       _nb_execute_loop                      ,
-       _ooo_engine_nb_front_end              ,//[nb_ooo_engine]
-       _ooo_engine_nb_execute_loop           ,//[nb_ooo_engine]
-       _execute_loop_nb_ooo_engine           ,//[nb_execute_loop]
-       _front_end_sum_inst_decod             ,//[nb_front_end] -> [sum_inst_decod]
-       _front_end_nb_inst_branch_complete    ,//[nb_front_end]
-       _nb_inst_branch_complete              ,//[nb_ooo_engine]
-//     _ooo_engine_nb_inst_insert_rob        ,//[nb_ooo_engine]
-       _nb_inst_reexecute                    ,//[nb_ooo_engine]
-       _nb_inst_issue_queue                  ,//[nb_ooo_engine]
-       _nb_inst_issue_slot                   ,//[nb_ooo_engine]
-       _ooo_engine_nb_inst_execute           ,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
-       _issue_queue_in_order                 ,//[nb_ooo_engine]
-       _nb_read_unit                         ,//[nb_execute_loop]
-       _nb_write_unit                        ,//[nb_execute_loop]
-       _size_depth                           ,
-       _size_rob_ptr                         ,
-       _size_load_queue_ptr                  ,
-       _size_store_queue_ptr                 ,
-       _size_general_data                    ,
-       _size_special_data                    ,
-       _size_general_register                ,
-       _size_special_register                ,
-       _dispatch_priority                    ,
-       _dispatch_load_balancing              ,
-       _network_table_dispatch               ,//[nb_ooo_engine][nb_inst_issue_slot][nb_execute_loop][nb_read_unit]
-       _network_table_issue_type             ,//                                   [nb_execute_loop][nb_read_unit][nb_type]
-       _translate_ooo_engine_num_front_end   ,//[nb_ooo_engine][ooo_engine_nb_front_end]
-       _translate_ooo_engine_num_execute_loop,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
-       _translate_execute_loop_num_ooo_engine //[nb_execute_loop][execute_loop_nb_ooo_engine]
+       _nb_front_end                                  ,
+       _nb_context                                    ,//[nb_front_end]
+       _nb_ooo_engine                                 ,
+       _nb_execute_loop                               ,
+       _ooo_engine_nb_front_end                       ,//[nb_ooo_engine]
+       _ooo_engine_nb_execute_loop                    ,//[nb_ooo_engine]
+       _execute_loop_nb_ooo_engine                    ,//[nb_execute_loop]
+       _front_end_sum_inst_decod                      ,//[nb_front_end] -> [sum_inst_decod]
+       _front_end_nb_inst_branch_complete             ,//[nb_front_end]
+       _nb_inst_branch_complete                       ,//[nb_ooo_engine]
+//     _ooo_engine_nb_inst_insert_rob                 ,//[nb_ooo_engine]
+       _nb_inst_reexecute                             ,//[nb_ooo_engine]
+       _nb_inst_issue_queue                           ,//[nb_ooo_engine]
+//     _nb_inst_issue_slot                            ,//[nb_ooo_engine]
+       _ooo_engine_nb_inst_execute                    ,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
+       _issue_queue_in_order                          ,//[nb_ooo_engine]
+       _nb_read_unit                                  ,//[nb_execute_loop]
+       _nb_write_unit                                 ,//[nb_execute_loop]
+       _size_depth                                    ,
+       _size_rob_ptr                                  ,
+       _size_load_queue_ptr                           ,
+       _size_store_queue_ptr                          ,
+       _size_general_data                             ,
+       _size_special_data                             ,
+       _size_general_register                         ,
+       _size_special_register                         ,
+       _dispatch_priority                             ,
+       _dispatch_load_balancing                       ,
+//     _network_table_dispatch                        ,//[nb_ooo_engine][nb_inst_issue_slot][nb_execute_loop][nb_read_unit]
+       _network_table_issue_type                      ,//                                   [nb_execute_loop][nb_read_unit][nb_type]
+       _network_table_issue_thread                    ,//                                   [nb_execute_loop][nb_read_unit][nb_thread]
+       _translate_ooo_engine_num_front_end            ,//[nb_ooo_engine][ooo_engine_nb_front_end]
+       _translate_ooo_engine_num_execute_loop         ,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
+       _translate_execute_loop_num_ooo_engine         ,//[nb_execute_loop][execute_loop_nb_ooo_engine]
+       _ooo_engine_translate_num_context_to_num_thread //[nb_ooo_engine][ooo_engine_nb_front_end][nb_context]
        );
     
@@ -2238,9 +2382,15 @@
     DELETE2(_execute_loop_size_execute_queue                        ,_nb_execute_loop,_nb_write_unit[it1]);
     DELETE2(_execute_loop_size_write_queue                          ,_nb_execute_loop,_nb_write_unit[it1]);
+    DELETE2(_execute_loop_nb_inst_write                             ,_nb_execute_loop,_nb_write_unit[it1]);
     DELETE2(_execute_loop_nb_inst_memory                            ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     DELETE2(_execute_loop_nb_cache_port                             ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     DELETE2(_execute_loop_nb_bypass_memory                          ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    DELETE3(_execute_loop_lsu_pht_nb_counter                        ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],1);
+    DELETE3(_execute_loop_lsu_pht_size_counter                      ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],1);
+    DELETE2(_execute_loop_speculative_commit_predictor_scheme       ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     DELETE2(_execute_loop_speculative_load                          ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     DELETE2(_execute_loop_nb_port_check                             ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    DELETE2(_execute_loop_nb_load_queue_bank                        ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
+    DELETE2(_execute_loop_nb_store_queue_bank                       ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     DELETE2(_execute_loop_size_speculative_access_queue             ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
     DELETE2(_execute_loop_size_load_queue                           ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
@@ -2253,4 +2403,5 @@
     DELETE2(_execute_loop_size_reservation_station                  ,_nb_execute_loop,_nb_read_unit[it1]);
     DELETE2(_execute_loop_size_read_queue                           ,_nb_execute_loop,_nb_read_unit[it1]);
+    DELETE2(_execute_loop_nb_inst_read                              ,_nb_execute_loop,_nb_read_unit[it1]);
     DELETE2(_translate_execute_loop_num_ooo_engine                  ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
     DELETE1(_execute_loop_nb_thread                                 ,_nb_execute_loop);
@@ -2273,6 +2424,7 @@
 //  DELETE3(_ooo_engine_table_issue_type                            ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_type);
 //  DELETE3(_ooo_engine_table_routing                               ,_nb_ooo_engine,_nb_rename_unit[it1],_nb_inst_issue_slot[it1]);
+    DELETE3(_network_table_issue_thread                                                                     ,_nb_execute_loop,_nb_read_unit[it1],_nb_thread);
     DELETE3(_network_table_issue_type                                                                       ,_nb_execute_loop,_nb_read_unit[it1],_nb_type);
-    DELETE4(_network_table_dispatch                                 ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_execute_loop,_nb_read_unit[it3]);
+//  DELETE4(_network_table_dispatch                                 ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_execute_loop,_nb_read_unit[it3]);
 //  DELETE2(_ooo_engine_size_read_counter                           ,_nb_ooo_engine,_nb_rename_unit[it1]);
     DELETE2(_ooo_engine_nb_rename_unit_bank                         ,_nb_ooo_engine,_nb_rename_unit[it1]);
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_msg_error.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_msg_error.cpp	(revision 137)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_msg_error.cpp	(revision 138)
@@ -24,6 +24,5 @@
     Parameters_test test ("Core");
 
-    // TESTER SI LES VALEURS NE DEPASSE PAS DE L'INTERVALLE AUTORISE
-
+    // Test if value is valid
     {
       // initialisation
@@ -191,4 +190,6 @@
           uint32_t num_execute_loop = _link_execute_unit_with_load_store_unit [i].first;
           uint32_t num_execute_unit = _link_execute_unit_with_load_store_unit [i].second;
+
+          log_printf(TRACE,Core,FUNCTION,"  * _link_execute_unit_with_load_store_unit  [%d] = %d.%d",i,num_execute_loop,num_execute_unit);
 
           nb_link_execute_unit [num_execute_loop][num_execute_unit] ++;
@@ -224,69 +225,36 @@
     
     {
-      // initialisation
-      uint32_t nb_link_slot      [_nb_ooo_engine][max<uint32_t>(_nb_inst_issue_slot,_nb_ooo_engine)];
-      uint32_t nb_link_read_bloc [_nb_read_bloc];
-  
-      // initialisation
-      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
-        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-          nb_link_slot [i][j] = 0;
+      bool     read_bloc_link_with_load_store_unit  [_nb_read_bloc];
+      bool     read_bloc_link_with_functionnal_unit [_nb_read_bloc];
+      uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
+      
       for (uint32_t i=0; i<_nb_read_bloc; ++i)
-        nb_link_read_bloc [i] = 0;
-
-      // set link
-      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
-        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-          for (uint32_t k=0; k<_nb_read_bloc; ++k)
-            if (_table_dispatch [i][j][k])
-              {
-                nb_link_slot      [i][j] ++;
-                nb_link_read_bloc [k] ++;
-              }
-      
-      // test
-      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
-        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-          if (nb_link_slot [i][j] == 0)
-            test.error(toString(_("In Out Of Order Engine [%d], the slot issue [%d] is not link with a read_bloc.\n"),i,j));
+        {
+          read_bloc_link_with_load_store_unit  [i] = false;
+          read_bloc_link_with_functionnal_unit [i] = false;
+        }
+      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
+        nb_link_functionnal_unit [i] = 0;
+      
+      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
+        read_bloc_link_with_load_store_unit [_link_read_bloc_with_load_store_unit[i]] = true;
+      
       for (uint32_t i=0; i<_nb_read_bloc; ++i)
-        if (nb_link_read_bloc [i] == 0)
-          test.error(toString(_("Read_bloc [%d] is not link with a issue's slot.\n"),i));
-    }
-
-    {
-      uint32_t nb_link_read_bloc        [_nb_read_bloc];
-      uint32_t nb_link_load_store_unit  [_nb_load_store_unit];
-      uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
+        for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
+          if (_link_read_bloc_and_functionnal_unit [i][j])
+            {
+              nb_link_functionnal_unit [j] ++;
+              read_bloc_link_with_functionnal_unit [i] = true;
+            }
 
       for (uint32_t i=0; i<_nb_read_bloc; ++i)
-        nb_link_read_bloc [i] = 0;
-      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
-        nb_link_load_store_unit [i] = 0;
-      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
-        nb_link_functionnal_unit [i] = 0;
-
-      for (uint32_t i=0; i<_nb_read_bloc; ++i)
-        {
-          for (uint32_t j=0; j<_nb_load_store_unit; ++j)
-            if (_link_read_bloc_and_load_store_unit [i][j])
-              {
-                nb_link_read_bloc        [i] ++;
-                nb_link_load_store_unit  [j] ++;
-              }
-          for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
-            if (_link_read_bloc_and_functionnal_unit [i][j])
-              {
-                nb_link_read_bloc        [i] ++;
-                nb_link_functionnal_unit [j] ++;
-              }
-        }
-
-      for (uint32_t i=0; i<_nb_read_bloc; ++i)
-        if (nb_link_read_bloc [i] == 0)
-          test.error(toString(_("Read_bloc [%d] is not link with an execute_unit.\n"),i));
-      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
-        if (nb_link_load_store_unit [i] == 0)
-          test.error(toString(_("load_store_unit [%d] is not link with a read_bloc.\n"),i));
+        {
+          if (not read_bloc_link_with_load_store_unit  [i] and
+              not read_bloc_link_with_functionnal_unit [i])
+            test.error(toString(_("Read_bloc [%d] is not link with an execute_unit.\n"),i));
+          if (    read_bloc_link_with_load_store_unit  [i] and
+                  read_bloc_link_with_functionnal_unit [i])
+            test.error(toString(_("Read_bloc [%d] is linked with an load store unit and functionnal unit.\n"),i));
+        }
       for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
         if (nb_link_functionnal_unit [i] == 0)
@@ -296,36 +264,25 @@
     {
       uint32_t nb_link_write_bloc       [_nb_write_bloc];
-      uint32_t nb_link_load_store_unit  [_nb_load_store_unit];
       uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
 
       for (uint32_t i=0; i<_nb_write_bloc; ++i)
         nb_link_write_bloc [i] = 0;
-      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
-        nb_link_load_store_unit [i] = 0;
       for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
         nb_link_functionnal_unit [i] = 0;
 
+      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
+        nb_link_write_bloc [_link_write_bloc_with_load_store_unit[i]] = true;
+
       for (uint32_t i=0; i<_nb_write_bloc; ++i)
-        {
-          for (uint32_t j=0; j<_nb_load_store_unit; ++j)
-            if (_link_write_bloc_and_load_store_unit [i][j])
-              {
-                nb_link_write_bloc       [i] ++;
-                nb_link_load_store_unit  [j] ++;
-              }
-          for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
-            if (_link_write_bloc_and_functionnal_unit [i][j])
-              {
-                nb_link_write_bloc       [i] ++;
-                nb_link_functionnal_unit [j] ++;
-              }
-        }
+        for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
+          if (_link_write_bloc_and_functionnal_unit [i][j])
+            {
+              nb_link_write_bloc       [i] ++;
+              nb_link_functionnal_unit [j] ++;
+            }
 
       for (uint32_t i=0; i<_nb_write_bloc; ++i)
         if (nb_link_write_bloc [i] == 0)
           test.error(toString(_("Write_bloc [%d] is not link with an execute_unit.\n"),i));
-      for (uint32_t i=0; i<_nb_load_store_unit; ++i)
-        if (nb_link_load_store_unit [i] == 0)
-          test.error(toString(_("load_store_unit [%d] is not link with a write_bloc.\n"),i));
       for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
         if (nb_link_functionnal_unit [i] == 0)
@@ -334,7 +291,9 @@
 
     {
-      uint32_t nb_link_thread           [_nb_thread];
-      uint32_t nb_link_load_store_unit  [_nb_load_store_unit];
-      uint32_t nb_link_functionnal_unit [_nb_functionnal_unit];
+      uint32_t nb_link_thread                      [_nb_thread];
+      uint32_t nb_link_load_store_unit             [_nb_load_store_unit];
+      uint32_t nb_link_functionnal_unit            [_nb_functionnal_unit];
+      bool     link_front_end_with_execute_loop    [_nb_front_end][_nb_execute_loop];
+      uint32_t nb_link_front_end_with_execute_loop [_nb_front_end];
 
       for (uint32_t i=0; i<_nb_thread; ++i)
@@ -344,12 +303,25 @@
       for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
         nb_link_functionnal_unit [i] = 0;
-      
-      for (uint32_t i=0; i<_nb_thread; ++i)
-        {
+      for (uint32_t i=0; i<_nb_front_end; ++i)
+        {
+          nb_link_front_end_with_execute_loop [i] = 0;
+          for (uint32_t j=0; j<_nb_execute_loop; ++j)
+            link_front_end_with_execute_loop [i][j] = false;
+        }
+
+      for (uint32_t i=0; i<_nb_thread; ++i)
+        {
+          uint32_t num_front_end = _link_context_with_thread [i].first;
+
           {
             uint32_t num_load_store_unit = _link_load_store_unit_with_thread [i];
+            uint32_t num_execute_loop    = _link_execute_unit_with_load_store_unit [i].first;
             
             nb_link_thread           [i] ++;
             nb_link_load_store_unit  [num_load_store_unit] ++;
+
+            if (not link_front_end_with_execute_loop [num_front_end][num_execute_loop])
+              nb_link_front_end_with_execute_loop [num_front_end] ++;
+            link_front_end_with_execute_loop [num_front_end][num_execute_loop] = true;
           }
 
@@ -357,6 +329,12 @@
             if (_link_thread_and_functionnal_unit [i][j])
               {
+                uint32_t num_execute_loop = _link_execute_unit_with_functionnal_unit [i].first;
+
                 nb_link_thread           [i] ++;
                 nb_link_functionnal_unit [j] ++;
+                
+                if (not link_front_end_with_execute_loop [num_front_end][num_execute_loop])
+                  nb_link_front_end_with_execute_loop [num_front_end] ++;
+                link_front_end_with_execute_loop [num_front_end][num_execute_loop] = true;
               }
         }
@@ -371,4 +349,7 @@
         if (nb_link_functionnal_unit [i] == 0)
           test.error(toString(_("Functionnal_unit [%d] is not link with a thread.\n"),i));
+      for (uint32_t i=0; i<_nb_front_end; ++i)
+        if (nb_link_front_end_with_execute_loop [i] != 1)
+          test.error(toString(_("Front end [%d] is link with many execute_loop.\n"),i));
     }
     
@@ -395,5 +376,5 @@
       for (uint32_t i=0; i<_nb_load_store_unit; ++i)
         for (uint32_t j=0; j<_nb_cache_port[i]; ++j)
-        nb_link_dcache_port [_link_dcache_port_with_load_store_unit[i][j]] ++;
+          nb_link_dcache_port [_link_dcache_port_with_load_store_unit[i][j]] ++;
       
       for (uint32_t i=0; i<_nb_dcache_port; ++i)
@@ -402,24 +383,4 @@
     }
 
-
-//   public : pair_dual             * _link_context_with_thread                      ;//[nb_thread]
-//   public : pair_dual             * _link_decod_unit_with_decod_bloc               ;//[nb_decod_bloc]
-//   public : pair_dual             * _link_rename_unit_with_rename_bloc             ;//[nb_rename_bloc]
-//   public : pair_dual             * _link_read_unit_with_read_bloc                 ;//[nb_read_bloc]
-//   public : pair_dual             * _link_write_unit_with_write_bloc               ;//[nb_write_bloc]
-//   public : pair_dual             * _link_execute_unit_with_functionnal_unit       ;//[nb_functionnal_unit]
-//   public : pair_dual             * _link_execute_unit_with_load_store_unit        ;//[nb_load_store_unit]
-//   public : uint32_t              * _link_decod_bloc_with_thread                   ;//[nb_thread]
-//   public : uint32_t              * _link_rename_bloc_with_front_end               ;//[nb_front_end]
-//   public : bool                *** _table_dispatch                                ;//[nb_ooo_engine][nb_inst_issue][nb_read_bloc]
-//   public : bool                 ** _link_read_bloc_and_load_store_unit            ;//[nb_read_bloc][nb_load_store_unit]
-//   public : bool                 ** _link_read_bloc_and_functionnal_unit           ;//[nb_read_bloc][nb_functionnal_unit]
-//   public : bool                 ** _link_write_bloc_and_load_store_unit           ;//[nb_write_bloc][nb_load_store_unit]
-//   public : bool                 ** _link_write_bloc_and_functionnal_unit          ;//[nb_write_bloc][nb_functionnal_unit]
-//   public : uint32_t              * _link_load_store_unit_with_thread              ;//[nb_thread]
-//   public : bool                 ** _link_thread_and_functionnal_unit              ;//[nb_thread][nb_functionnal_unit]
-//   public : uint32_t              * _link_icache_port_with_thread                  ;//[nb_thread]
-//   public : uint32_t             ** _link_dcache_port_with_load_store_unit         ;//[nb_load_store_unit][nb_cache_port]
-
     log_end(Core,FUNCTION);
 
Index: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_print.cpp
===================================================================
--- trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_print.cpp	(revision 137)
+++ trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters_print.cpp	(revision 138)
@@ -176,5 +176,4 @@
     str+= toString(MSG_INFORMATION)+"     * nb_rename_unit                              : "+toString<uint32_t         >(_nb_rename_unit          [i])+"\n";
     str+= toString(MSG_INFORMATION)+"     * nb_inst_issue_queue                         : "+toString<uint32_t         >(_nb_inst_issue_queue     [i])+"\n";
-    str+= toString(MSG_INFORMATION)+"     * nb_inst_issue_slot                          : "+toString<uint32_t         >(_nb_inst_issue_slot      [i])+"\n";
     str+= toString(MSG_INFORMATION)+"     * nb_inst_reexecute                           : "+toString<uint32_t         >(_nb_inst_reexecute       [i])+"\n";
     str+= toString(MSG_INFORMATION)+"     * nb_inst_commit                              : "+toString<uint32_t         >(_nb_inst_commit          [i])+"\n";
@@ -193,6 +192,4 @@
     str+= toString(MSG_INFORMATION)+"     * issue_load_balancing                        : "+toString<Tload_balancing_t>(_issue_load_balancing    [i])+"\n";
     str+= toString(MSG_INFORMATION)+"     * size_reexecute_queue                        : "+toString<uint32_t         >(_size_reexecute_queue    [i])+"\n";
-    str+= toString(MSG_INFORMATION)+"     * reexecute_priority                          : "+toString<Tpriority_t      >(_reexecute_priority      [i])+"\n";
-    str+= toString(MSG_INFORMATION)+"     * reexecute_load_balancing                    : "+toString<Tload_balancing_t>(_reexecute_load_balancing[i])+"\n";
       }
 
@@ -245,13 +242,11 @@
 
     
-    for (uint32_t i=0; i<_nb_read_bloc; ++i)
-      for (uint32_t j=0; j<_nb_load_store_unit; ++j)
-    str+= toString(MSG_INFORMATION)+"   * link_read_bloc_and_load_store_unit              ["+toString(i)+"]["+toString(j)+"] : "+toString(_link_read_bloc_and_load_store_unit  [i][j])+"\n";//[nb_read_bloc][nb_load_store_unit]
+    for (uint32_t i=0; i<_nb_load_store_unit; ++i)
+    str+= toString(MSG_INFORMATION)+"   * link_read_bloc_with_load_store_unit             ["+toString(i)+"] : "+toString(_link_read_bloc_with_load_store_unit  [i])+"\n";//[nb_load_store_unit]
     for (uint32_t i=0; i<_nb_read_bloc; ++i)
       for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
     str+= toString(MSG_INFORMATION)+"   * link_read_bloc_and_functionnal_unit             ["+toString(i)+"]["+toString(j)+"] : "+toString(_link_read_bloc_and_functionnal_unit [i][j])+"\n";//[nb_read_bloc][nb_functionnal_unit]
-    for (uint32_t i=0; i<_nb_write_bloc; ++i)
-      for (uint32_t j=0; j<_nb_load_store_unit; ++j)
-    str+= toString(MSG_INFORMATION)+"   * link_write_bloc_and_load_store_unit             ["+toString(i)+"]["+toString(j)+"] : "+toString(_link_write_bloc_and_load_store_unit [i][j])+"\n";//[nb_write_bloc][nb_load_store_unit]
+    for (uint32_t i=0; i<_nb_load_store_unit; ++i)
+    str+= toString(MSG_INFORMATION)+"   * link_write_bloc_with_load_store_unit            ["+toString(i)+"] : "+toString(_link_write_bloc_with_load_store_unit [i])+"\n";//[nb_load_store_unit]
     for (uint32_t i=0; i<_nb_write_bloc; ++i)
       for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
@@ -262,10 +257,4 @@
 
     str+= toString(MSG_INFORMATION)+" -----[ Dispatch ]---------------------------------\n";
-
-    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
-      for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
-        for (uint32_t k=0; k<_nb_read_bloc; ++k)
-    str+= toString(MSG_INFORMATION)+"   * table_dispatch                                  ["+toString(i)+"]["+toString(j)+"]["+toString(k)+"] : "+toString(_table_dispatch                      [i][j][k])+"\n";//[nb_ooo_engine][nb_inst_issue][nb_read_bloc]
-
     str+= toString(MSG_INFORMATION)+"   * dispatch_priority                             : "+toString<Tpriority_t      >(_dispatch_priority      )+"\n";
     str+= toString(MSG_INFORMATION)+"   * dispatch_load_balancing                       : "+toString<Tload_balancing_t>(_dispatch_load_balancing);
