source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/src/Parameters.cpp @ 128

Last change on this file since 128 was 128, checked in by rosiere, 15 years ago

1) Correct bug in link two signal
2) Fix error detected with valgrind
3) modif distexe script
  • Property svn:keywords set to Id
File size: 177.8 KB
Line 
1/*
2 * $id$
3 *
4 * [ description ]
5 *
6 */
7
8#include "Behavioural/Core/include/Parameters.h"
9#include "Behavioural/include/Allocation.h"
10#include "Common/include/Max.h"
11#include <algorithm>
12
13namespace morpheo {
14namespace behavioural {
15namespace core {
16
17#undef  FUNCTION
18#define FUNCTION "Core::get_num_thread"
19  Tcontext_t Parameters::execute_loop_get_num_thread (uint32_t num_execute_loop,
20                                                      uint32_t num_thread)
21  {
22    log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_get_num_thread"));
23    log_printf(TRACE,Core,FUNCTION,_("    * num_execute_loop : %d"),num_execute_loop);
24    log_printf(TRACE,Core,FUNCTION,_("    * num_thread       : %d"),num_thread);
25
26    // compute all id !
27    //  * initialisation
28    uint32_t num_context    = _link_context_with_thread [num_thread].second;
29    uint32_t num_front_end  = _link_context_with_thread [num_thread].first;
30    uint32_t num_ooo_engine = _link_rename_unit_with_rename_bloc[_link_rename_bloc_with_front_end [num_front_end]].first;
31
32    log_printf(TRACE,Core,FUNCTION,_("    * num_context      : %d"),num_context   );
33    log_printf(TRACE,Core,FUNCTION,_("    * num_front_end    : %d"),num_front_end );
34    log_printf(TRACE,Core,FUNCTION,_("    * num_ooo_engine   : %d"),num_ooo_engine);
35   
36    uint32_t context_id   = num_context;
37    uint32_t front_end_id ;
38    uint32_t ooo_engine_id;
39
40    //  * compute
41    for (ooo_engine_id=0; ooo_engine_id<_execute_loop_nb_ooo_engine [num_execute_loop]; ++ooo_engine_id)
42      if (_list_ooo_engine_with_execute_loop [num_execute_loop][ooo_engine_id] == num_ooo_engine)
43        break;
44   
45    if (ooo_engine_id == _execute_loop_nb_ooo_engine [num_execute_loop])
46      return static_cast<Tcontext_t>(-1);
47
48    log_printf(TRACE,Core,FUNCTION,_("    * ooo_engine_id    : %d"),ooo_engine_id);
49   
50    for (front_end_id=0; front_end_id<_ooo_engine_nb_front_end[num_ooo_engine]; ++front_end_id)
51      if (_translate_ooo_engine_num_front_end [num_ooo_engine][front_end_id] == num_front_end)
52        break;
53   
54    if (front_end_id == _execute_loop_nb_front_end [num_execute_loop])
55      return static_cast<Tcontext_t>(-1);
56
57    log_printf(TRACE,Core,FUNCTION,_("    * front_end_id     : %d"),front_end_id );
58
59    Tcontext_t _return = get_num_thread(context_id   , log2(_execute_loop_nb_context    [num_execute_loop]),
60                                        front_end_id , log2(_execute_loop_nb_front_end  [num_execute_loop]),
61                                        ooo_engine_id, log2(_execute_loop_nb_ooo_engine [num_execute_loop]));
62
63    log_printf(TRACE,Core,FUNCTION,_("    * return           : %d"),_return);
64
65    // compute the thread number
66    return _return;
67  }
68
69
70#undef  FUNCTION
71#define FUNCTION "Core::Parameters"
72  Parameters::Parameters (
73  // Common
74  uint32_t                size_general_data                             ,
75  uint32_t                size_special_data                             ,
76  morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
77   
78  // Thread
79  uint32_t                nb_thread                                     ,
80  uint32_t              * size_ifetch_queue                             ,//[nb_thread]
81  uint32_t              * nb_inst_fetch                                 ,//[nb_thread]
82  bool                 ** implement_group                               ,//[nb_thread][NB_GROUP]
83  uint32_t              * ras_size_queue                                ,//[nb_thread]
84  uint32_t              * upt_size_queue                                ,//[nb_thread]
85  uint32_t              * ufpt_size_queue                               ,//[nb_thread]
86
87  // Decod bloc
88  uint32_t                nb_decod_bloc                                 ,
89  uint32_t              * size_decod_queue                              ,//[nb_decod_bloc]
90  multi_front_end::front_end::decod_unit::decod_queue::Tdecod_queue_scheme_t
91                        * decod_queue_scheme                            ,//[nb_decod_bloc]
92  uint32_t              * nb_inst_decod                                 ,//[nb_decod_bloc]
93  uint32_t              * nb_context_select                             ,//[nb_decod_bloc]
94  Tpriority_t           * context_select_priority                       ,//[nb_decod_bloc]
95  Tload_balancing_t     * context_select_load_balancing                 ,//[nb_decod_bloc]
96
97  // Rename bloc
98  uint32_t                nb_rename_bloc                                ,
99  uint32_t              * nb_inst_insert                                ,//[nb_rename_bloc]
100  uint32_t              * nb_inst_retire                                ,//[nb_rename_bloc]
101  Tpriority_t           * rename_select_priority                        ,//[nb_rename_bloc]
102  Tload_balancing_t     * rename_select_load_balancing                  ,//[nb_rename_bloc]
103  uint32_t              * rename_select_nb_front_end_select             ,//[nb_rename_bloc]
104  uint32_t              * nb_general_register                           ,//[nb_rename_bloc]
105  uint32_t              * nb_special_register                           ,//[nb_rename_bloc]
106  uint32_t              * nb_reg_free                                   ,//[nb_rename_bloc]
107  uint32_t              * nb_rename_unit_bank                           ,//[nb_rename_bloc]
108//uint32_t              * size_read_counter                             ,//[nb_rename_bloc]
109
110  // Read bloc
111  uint32_t                nb_read_bloc                                  ,//
112  uint32_t              * size_read_queue                               ,//[nb_read_bloc]
113  uint32_t              * size_reservation_station                      ,//[nb_read_bloc]
114  uint32_t              * nb_inst_retire_reservation_station            ,//[nb_read_bloc]
115
116  // Write bloc
117  uint32_t                nb_write_bloc                                 ,//
118  uint32_t              * size_write_queue                              ,//[nb_write_bloc]
119  uint32_t              * size_execute_queue                            ,//[nb_write_bloc]
120  uint32_t              * nb_bypass_write                               ,//[nb_write_bloc]
121  multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t * write_queue_scheme,//[nb_write_bloc]
122
123  // Load_store_unit
124  uint32_t                nb_load_store_unit                            ,
125  uint32_t              * size_store_queue                              ,//[nb_load_store_unit]
126  uint32_t              * size_load_queue                               ,//[nb_load_store_unit]
127  uint32_t              * size_speculative_access_queue                 ,//[nb_load_store_unit]
128  uint32_t              * nb_port_check                                 ,//[nb_load_store_unit]
129  multi_execute_loop::execute_loop::Tspeculative_load_t 
130                        * speculative_load                              ,//[nb_load_store_unit]
131  uint32_t              * nb_bypass_memory                              ,//[nb_load_store_unit]
132  uint32_t              * nb_cache_port                                 ,//[nb_load_store_unit]
133  uint32_t              * nb_inst_memory                                ,//[nb_load_store_unit]
134
135  // Functionnal_unit
136  uint32_t                nb_functionnal_unit                           ,
137  uint32_t              * nb_inst_functionnal_unit                      ,//[nb_functionnal_unit]
138  multi_execute_loop::execute_loop::execute_timing_t
139                      *** timing                                        ,//[nb_functionnal_unit][_nb_type][_nb_operation]
140
141  // Icache_Access
142  uint32_t                nb_icache_port                                ,
143  Tpriority_t             icache_port_priority                        ,
144  Tload_balancing_t       icache_port_load_balancing                  ,
145
146  // Dcache_Access
147  uint32_t                nb_dcache_port                                ,
148  Tpriority_t             dcache_port_priority                        ,
149  Tload_balancing_t       dcache_port_load_balancing                  ,
150
151  // Front_end
152  uint32_t                nb_front_end                                  ,
153  uint32_t              * nb_context                                    ,//[nb_front_end]
154  uint32_t              * nb_decod_unit                                 ,//[nb_front_end]
155  uint32_t              * nb_inst_branch_predict                        ,//[nb_front_end]
156  uint32_t              * nb_inst_branch_decod                          ,//[nb_front_end]
157  uint32_t              * nb_inst_branch_update                         ,//[nb_front_end]
158  uint32_t              * btb_size_queue                                ,//[nb_front_end]
159  uint32_t              * btb_associativity                             ,//[nb_front_end]
160  uint32_t              * btb_size_counter                              ,//[nb_front_end]
161  Tvictim_t             * btb_victim_scheme                             ,//[nb_front_end]
162  Tpredictor_t          * dir_predictor_scheme                          ,//[nb_front_end]
163  bool                 ** dir_have_bht                                  ,//[nb_front_end][3]
164  uint32_t             ** dir_bht_size_shifter                          ,//[nb_front_end][3]
165  uint32_t             ** dir_bht_nb_shifter                            ,//[nb_front_end][3]
166  bool                 ** dir_have_pht                                  ,//[nb_front_end][3]
167  uint32_t             ** dir_pht_size_counter                          ,//[nb_front_end][3]
168  uint32_t             ** dir_pht_nb_counter                            ,//[nb_front_end][3]
169  uint32_t             ** dir_pht_size_address_share                    ,//[nb_front_end][3]
170
171  // OOO_Engine
172  uint32_t                nb_ooo_engine                                 ,
173  uint32_t              * nb_rename_unit                                ,//[nb_ooo_engine]
174  uint32_t              * nb_inst_issue_slot                            ,//[nb_ooo_engine]
175  uint32_t              * nb_inst_reexecute                             ,//[nb_ooo_engine]
176  uint32_t              * nb_inst_commit                                ,//[nb_ooo_engine]
177  uint32_t              * nb_inst_branch_complete                       ,//[nb_ooo_engine]
178  uint32_t              * nb_rename_unit_select                         ,//[nb_ooo_engine]
179  uint32_t              * nb_execute_loop_select                        ,//[nb_ooo_engine]
180  uint32_t              * size_re_order_buffer                          ,//[nb_ooo_engine]
181  uint32_t              * nb_re_order_buffer_bank                       ,//[nb_ooo_engine]
182  Tpriority_t           * commit_priority                               ,//[nb_ooo_engine]
183  Tload_balancing_t     * commit_load_balancing                         ,//[nb_ooo_engine]
184  uint32_t              * size_issue_queue                              ,//[nb_ooo_engine]
185  multi_ooo_engine::ooo_engine::issue_queue::Tissue_queue_scheme_t
186                        * issue_queue_scheme                            ,//[nb_ooo_engine]
187  uint32_t              * nb_issue_queue_bank                           ,//[nb_ooo_engine]
188  Tpriority_t           * issue_priority                                ,//[nb_ooo_engine]
189  Tload_balancing_t     * issue_load_balancing                          ,//[nb_ooo_engine]
190  uint32_t              * size_reexecute_queue                          ,//[nb_ooo_engine]
191  Tpriority_t           * reexecute_priority                            ,//[nb_ooo_engine]
192  Tload_balancing_t     * reexecute_load_balancing                      ,//[nb_ooo_engine]
193
194  //Execute_loop
195  uint32_t                nb_execute_loop                               ,
196  uint32_t              * nb_read_unit                                  ,//[nb_execute_loop]
197  uint32_t              * nb_execute_unit                               ,//[nb_execute_loop]
198  uint32_t              * nb_write_unit                                 ,//[nb_execute_loop]
199  uint32_t              * nb_gpr_bank                                   ,//[nb_execute_loop]
200  uint32_t              * nb_gpr_port_read_by_bank                      ,//[nb_execute_loop]
201  uint32_t              * nb_gpr_port_write_by_bank                     ,//[nb_execute_loop]
202  uint32_t              * nb_spr_bank                                   ,//[nb_execute_loop]
203  uint32_t              * nb_spr_port_read_by_bank                      ,//[nb_execute_loop]
204  uint32_t              * nb_spr_port_write_by_bank                     ,//[nb_execute_loop]
205  Tpriority_t           * execution_unit_to_write_unit_priority         ,//[nb_execute_loop]
206  Tpriority_t           * read_unit_to_execution_unit_priority          ,//[nb_execute_loop]
207
208  // Link
209  pair_dual             * link_context_with_thread                      ,//[nb_thread]
210  pair_dual             * link_decod_unit_with_decod_bloc               ,//[nb_decod_bloc]
211  pair_dual             * link_rename_unit_with_rename_bloc             ,//[nb_rename_bloc]
212  pair_dual             * link_read_unit_with_read_bloc                 ,//[nb_read_bloc]
213  pair_dual             * link_write_unit_with_write_bloc               ,//[nb_write_bloc]
214  pair_dual             * link_execute_unit_with_functionnal_unit       ,//[nb_functionnal_unit]
215  pair_dual             * link_execute_unit_with_load_store_unit        ,//[nb_load_store_unit]
216  uint32_t              * link_decod_bloc_with_thread                   ,//[nb_thread]
217  uint32_t              * link_rename_bloc_with_front_end               ,//[nb_front_end]
218  bool                *** table_dispatch                                ,//[nb_ooo_engine][nb_inst_issue_slot][nb_read_bloc]
219  bool                 ** link_read_bloc_and_load_store_unit            ,//[nb_read_bloc][nb_load_store_unit]
220  bool                 ** link_read_bloc_and_functionnal_unit           ,//[nb_read_bloc][nb_functionnal_unit]
221  bool                 ** link_write_bloc_and_load_store_unit           ,//[nb_write_bloc][nb_load_store_unit]
222  bool                 ** link_write_bloc_and_functionnal_unit          ,//[nb_write_bloc][nb_functionnal_unit]
223  uint32_t              * link_load_store_unit_with_thread              ,//[nb_thread]
224  bool                 ** link_thread_and_functionnal_unit              ,//[nb_thread][nb_functionnal_unit]
225  uint32_t              * link_icache_port_with_thread                  ,//[nb_thread]
226  uint32_t             ** link_dcache_port_with_load_store_unit         ,//[nb_load_store_unit][nb_cache_port]
227
228  Tpriority_t             dispatch_priority                             ,
229  Tload_balancing_t       dispatch_load_balancing                       
230                        )
231  {
232    log_begin(Core,FUNCTION);
233   
234    _size_general_data                       = size_general_data                       ;
235    _size_special_data                       = size_special_data                       ;
236    _get_custom_information                  = get_custom_information                  ;
237
238    _nb_thread                               = nb_thread                               ;
239    _size_ifetch_queue                       = size_ifetch_queue                       ;
240    _nb_inst_fetch                           = nb_inst_fetch                           ;
241    _implement_group                         = implement_group                         ;
242    _ras_size_queue                          = ras_size_queue                          ;
243    _upt_size_queue                          = upt_size_queue                          ;
244    _ufpt_size_queue                         = ufpt_size_queue                         ;
245
246    _nb_decod_bloc                           = nb_decod_bloc                           ;
247    _size_decod_queue                        = size_decod_queue                        ;
248    _decod_queue_scheme                      = decod_queue_scheme                      ;
249    _nb_inst_decod                           = nb_inst_decod                           ;
250    _nb_context_select                       = nb_context_select                       ;
251    _context_select_priority                 = context_select_priority                 ;
252    _context_select_load_balancing           = context_select_load_balancing           ;
253
254    _nb_rename_bloc                          = nb_rename_bloc                          ;
255    _nb_inst_insert                          = nb_inst_insert                          ;
256    _nb_inst_retire                          = nb_inst_retire                          ;
257    _rename_select_priority                  = rename_select_priority                  ;
258    _rename_select_load_balancing            = rename_select_load_balancing            ;
259    _rename_select_nb_front_end_select       = rename_select_nb_front_end_select       ;
260    _nb_general_register                     = nb_general_register                     ;
261    _nb_special_register                     = nb_special_register                     ;
262    _nb_reg_free                             = nb_reg_free                             ;
263    _nb_rename_unit_bank                     = nb_rename_unit_bank                     ;
264//     _size_read_counter                       = size_read_counter                       ;
265
266    _nb_read_bloc                            = nb_read_bloc                            ;
267    _size_read_queue                         = size_read_queue                         ;
268    _size_reservation_station                = size_reservation_station                ;
269    _nb_inst_retire_reservation_station      = nb_inst_retire_reservation_station      ;
270
271    _nb_write_bloc                           = nb_write_bloc                           ;
272    _size_write_queue                        = size_write_queue                        ;
273    _size_execute_queue                      = size_execute_queue                      ;
274    _nb_bypass_write                         = nb_bypass_write                         ;
275    _write_queue_scheme                      = write_queue_scheme                      ;
276
277    _nb_load_store_unit                      = nb_load_store_unit                      ;
278    _size_store_queue                        = size_store_queue                        ;
279    _size_load_queue                         = size_load_queue                         ;
280    _size_speculative_access_queue           = size_speculative_access_queue           ;
281    _nb_port_check                           = nb_port_check                           ;
282    _speculative_load                        = speculative_load                        ;
283    _nb_bypass_memory                        = nb_bypass_memory                        ;
284    _nb_cache_port                           = nb_cache_port                           ;
285    _nb_inst_memory                          = nb_inst_memory                          ;
286
287    _nb_functionnal_unit                     = nb_functionnal_unit                     ;
288    _nb_inst_functionnal_unit                = nb_inst_functionnal_unit                ;
289    _timing                                  = timing                                  ;
290
291    _nb_icache_port                          = nb_icache_port                          ;
292    _icache_port_priority                    = icache_port_priority                    ;
293    _icache_port_load_balancing              = icache_port_load_balancing              ;
294
295    _nb_dcache_port                          = nb_dcache_port                          ;
296    _dcache_port_priority                    = dcache_port_priority                    ;
297    _dcache_port_load_balancing              = dcache_port_load_balancing              ;
298
299    _nb_front_end                            = nb_front_end                            ;
300    _nb_context                              = nb_context                              ;
301    _nb_decod_unit                           = nb_decod_unit                           ;
302    _nb_inst_branch_predict                  = nb_inst_branch_predict                  ;
303    _nb_inst_branch_decod                    = nb_inst_branch_decod                    ;
304    _nb_inst_branch_update                   = nb_inst_branch_update                   ;
305    _btb_size_queue                          = btb_size_queue                          ;
306    _btb_associativity                       = btb_associativity                       ;
307    _btb_size_counter                        = btb_size_counter                        ;
308    _btb_victim_scheme                       = btb_victim_scheme                       ;
309    _dir_predictor_scheme                    = dir_predictor_scheme                    ;
310    _dir_have_bht                            = dir_have_bht                            ;
311    _dir_bht_size_shifter                    = dir_bht_size_shifter                    ;
312    _dir_bht_nb_shifter                      = dir_bht_nb_shifter                      ;
313    _dir_have_pht                            = dir_have_pht                            ;
314    _dir_pht_size_counter                    = dir_pht_size_counter                    ;
315    _dir_pht_nb_counter                      = dir_pht_nb_counter                      ;
316    _dir_pht_size_address_share              = dir_pht_size_address_share              ;
317
318    _nb_ooo_engine                           = nb_ooo_engine                           ;
319    _nb_rename_unit                          = nb_rename_unit                          ;
320    _nb_inst_issue_slot                      = nb_inst_issue_slot                      ;
321    _nb_inst_reexecute                       = nb_inst_reexecute                       ;
322    _nb_inst_commit                          = nb_inst_commit                          ;
323    _nb_inst_branch_complete                 = nb_inst_branch_complete                 ;
324    _nb_rename_unit_select                   = nb_rename_unit_select                   ;
325    _nb_execute_loop_select                  = nb_execute_loop_select                  ;
326    _size_re_order_buffer                    = size_re_order_buffer                    ;
327    _nb_re_order_buffer_bank                 = nb_re_order_buffer_bank                 ;
328    _commit_priority                         = commit_priority                         ;
329    _commit_load_balancing                   = commit_load_balancing                   ;
330    _size_issue_queue                        = size_issue_queue                        ;
331    _issue_queue_scheme                      = issue_queue_scheme                      ;
332    _nb_issue_queue_bank                     = nb_issue_queue_bank                     ;
333    _issue_priority                          = issue_priority                          ;
334    _issue_load_balancing                    = issue_load_balancing                    ;
335    _size_reexecute_queue                    = size_reexecute_queue                    ;
336    _reexecute_priority                      = reexecute_priority                      ;
337    _reexecute_load_balancing                = reexecute_load_balancing                ;
338
339    _nb_execute_loop                         = nb_execute_loop                         ;
340    _nb_read_unit                            = nb_read_unit                            ;
341    _nb_execute_unit                         = nb_execute_unit                         ;
342    _nb_write_unit                           = nb_write_unit                           ;
343    _nb_gpr_bank                             = nb_gpr_bank                             ;
344    _nb_gpr_port_read_by_bank                = nb_gpr_port_read_by_bank                ;
345    _nb_gpr_port_write_by_bank               = nb_gpr_port_write_by_bank               ;
346    _nb_spr_bank                             = nb_spr_bank                             ;
347    _nb_spr_port_read_by_bank                = nb_spr_port_read_by_bank                ;
348    _nb_spr_port_write_by_bank               = nb_spr_port_write_by_bank               ;
349    _execution_unit_to_write_unit_priority   = execution_unit_to_write_unit_priority   ;
350    _read_unit_to_execution_unit_priority    = read_unit_to_execution_unit_priority    ;
351
352    _link_context_with_thread                = link_context_with_thread                ;
353    _link_decod_unit_with_decod_bloc         = link_decod_unit_with_decod_bloc         ;
354    _link_rename_unit_with_rename_bloc       = link_rename_unit_with_rename_bloc       ;
355    _link_read_unit_with_read_bloc           = link_read_unit_with_read_bloc           ;
356    _link_write_unit_with_write_bloc         = link_write_unit_with_write_bloc         ;
357    _link_execute_unit_with_functionnal_unit = link_execute_unit_with_functionnal_unit ;
358    _link_execute_unit_with_load_store_unit  = link_execute_unit_with_load_store_unit  ;
359    _link_decod_bloc_with_thread             = link_decod_bloc_with_thread             ;
360    _link_rename_bloc_with_front_end         = link_rename_bloc_with_front_end         ;
361    _table_dispatch                          = table_dispatch                          ;
362    _link_read_bloc_and_load_store_unit      = link_read_bloc_and_load_store_unit      ;
363    _link_read_bloc_and_functionnal_unit     = link_read_bloc_and_functionnal_unit     ;
364    _link_write_bloc_and_load_store_unit     = link_write_bloc_and_load_store_unit     ;
365    _link_write_bloc_and_functionnal_unit    = link_write_bloc_and_functionnal_unit    ;
366    _link_load_store_unit_with_thread        = link_load_store_unit_with_thread        ;
367    _link_thread_and_functionnal_unit        = link_thread_and_functionnal_unit        ;
368    _link_icache_port_with_thread            = link_icache_port_with_thread            ;
369    _link_dcache_port_with_load_store_unit   = link_dcache_port_with_load_store_unit   ;
370
371    _dispatch_priority                       = dispatch_priority                       ;
372    _dispatch_load_balancing                 = dispatch_load_balancing                 ;
373
374    test();
375
376    log_printf(TRACE,Core,FUNCTION,_("Core parameters :"));
377
378    log_printf(TRACE,Core,FUNCTION,_("  * nb_thread : %d"),_nb_thread);
379
380    // inverse link
381    ALLOC2(_link_thread_with_context                      ,uint32_t         ,_nb_front_end,_nb_context[it1]);
382    ALLOC2(_link_decod_bloc_with_decod_unit               ,uint32_t         ,_nb_front_end,_nb_decod_unit[it1]);
383    ALLOC2(_link_rename_bloc_with_rename_unit             ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
384    ALLOC2(_link_read_bloc_with_read_unit                 ,uint32_t         ,_nb_execute_loop,_nb_read_unit[it1]);
385    ALLOC2(_link_write_bloc_with_write_unit               ,uint32_t         ,_nb_execute_loop,_nb_write_unit[it1]);
386    ALLOC2(_link_functionnal_unit_with_execute_unit       ,uint32_t         ,_nb_execute_loop,_nb_execute_unit[it1]);
387    ALLOC2(_link_load_store_unit_with_execute_unit        ,uint32_t         ,_nb_execute_loop,_nb_execute_unit[it1]);
388    ALLOC1(_list_functionnal_unit_with_execute_unit       ,std::vector<uint32_t>,_nb_execute_loop);
389    ALLOC1(_list_load_store_unit_with_execute_unit        ,std::vector<uint32_t>,_nb_execute_loop);
390
391    for (uint32_t i=0; i<_nb_thread; ++i)
392      {
393        pair_dual x = _link_context_with_thread[i];
394        _link_thread_with_context [x.first][x.second] = i;
395      }
396
397//     log_printf(TRACE,Core,FUNCTION,_("  * _link_decod_unit_with_decod_bloc"));
398    for (uint32_t i=0; i<_nb_decod_bloc; ++i)
399      {
400        pair_dual x = _link_decod_unit_with_decod_bloc[i];
401        _link_decod_bloc_with_decod_unit [x.first][x.second] = i;
402//         log_printf(TRACE,Core,FUNCTION,_("    [%d][%d] -> %d"),x.first,x.second,i);
403      }
404
405    for (uint32_t i=0; i<_nb_rename_bloc; ++i)
406      {
407        pair_dual x = _link_rename_unit_with_rename_bloc[i];
408        _link_rename_bloc_with_rename_unit [x.first][x.second] = i;
409      }
410    for (uint32_t i=0; i<_nb_read_bloc; ++i)
411      {
412        pair_dual x = _link_read_unit_with_read_bloc[i];
413        _link_read_bloc_with_read_unit [x.first][x.second] = i;
414      }
415    for (uint32_t i=0; i<_nb_write_bloc; ++i)
416      {
417        pair_dual x = _link_write_unit_with_write_bloc[i];
418        _link_write_bloc_with_write_unit [x.first][x.second] = i;
419      }
420
421    for (uint32_t i=0; i<_nb_execute_loop; ++i)
422      for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
423        {
424          // init with an invalid value
425          _link_functionnal_unit_with_execute_unit [i][j] = _nb_functionnal_unit;
426          _link_load_store_unit_with_execute_unit  [i][j] = _nb_load_store_unit;
427        }
428
429    for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
430      {
431        pair_dual x = _link_execute_unit_with_functionnal_unit[i];
432        _link_functionnal_unit_with_execute_unit [x.first][x.second] = i;
433      }
434    for (uint32_t i=0; i<_nb_load_store_unit; ++i)
435      {
436        pair_dual x = _link_execute_unit_with_load_store_unit[i];
437        _link_load_store_unit_with_execute_unit [x.first][x.second] = i;
438      }
439
440    for (uint32_t i=0; i<_nb_execute_loop; ++i)
441      for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
442        {
443          log_printf(TRACE,Core,FUNCTION,_("  * execute_unit [%d][%d] : functionnal_unit [%d] - load_store_unit [%d]"),i,j,_link_functionnal_unit_with_execute_unit [i][j],_link_load_store_unit_with_execute_unit [i][j]);
444         
445
446          if (_link_functionnal_unit_with_execute_unit [i][j] != _nb_functionnal_unit)
447            _list_functionnal_unit_with_execute_unit [i].push_back(_link_functionnal_unit_with_execute_unit [i][j]);
448          if (_link_load_store_unit_with_execute_unit [i][j] != _nb_load_store_unit)
449            _list_load_store_unit_with_execute_unit [i].push_back(_link_load_store_unit_with_execute_unit [i][j]);
450        }     
451
452    // translate for front_end
453    ALLOC2(_front_end_size_ifetch_queue                   ,uint32_t         ,_nb_front_end,_nb_context[it1]);
454    ALLOC2(_front_end_nb_inst_fetch                       ,uint32_t         ,_nb_front_end,_nb_context[it1]);
455    ALLOC2(_front_end_link_decod_unit_with_context        ,uint32_t         ,_nb_front_end,_nb_context[it1]);
456    ALLOC2(_front_end_ras_size_queue                      ,uint32_t         ,_nb_front_end,_nb_context[it1]);
457    ALLOC2(_front_end_upt_size_queue                      ,uint32_t         ,_nb_front_end,_nb_context[it1]);
458    ALLOC2(_front_end_ufpt_size_queue                     ,uint32_t         ,_nb_front_end,_nb_context[it1]);
459
460    for (uint32_t i=0; i<_nb_front_end; ++i)
461      for (uint32_t j=0; j<_nb_context[i]; ++j)
462        {
463          uint32_t num_thread     = _link_thread_with_context[i][j];
464
465          _front_end_size_ifetch_queue            [i][j] = _size_ifetch_queue [num_thread];
466          _front_end_nb_inst_fetch                [i][j] = _nb_inst_fetch     [num_thread];
467          _front_end_ras_size_queue               [i][j] = _ras_size_queue    [num_thread];
468          _front_end_upt_size_queue               [i][j] = _upt_size_queue    [num_thread];
469          _front_end_ufpt_size_queue              [i][j] = _ufpt_size_queue   [num_thread];
470
471          uint32_t num_decod_bloc = _link_decod_bloc_with_thread [num_thread];
472          uint32_t num_decod_unit = _link_decod_unit_with_decod_bloc [num_decod_bloc].second;
473
474          _front_end_link_decod_unit_with_context [i][j] = num_decod_unit;
475        }
476
477    ALLOC3(_front_end_instruction_implemeted              ,bool             ,_nb_front_end,_nb_context[it1],NB_INSTRUCTION);
478
479    // Reset instruction implemented
480    for (uint32_t i=0; i<_nb_front_end; ++i)
481      for (uint32_t j=0; j<_nb_context[i]; ++j)
482        for (uint32_t k=0; k<NB_INSTRUCTION; ++k)
483          _front_end_instruction_implemeted[i][j][k] = false;
484
485    for (uint32_t i=0; i<_nb_thread; ++i)
486      {
487        uint32_t num_front_end = _link_context_with_thread [i].first;
488        uint32_t num_context   = _link_context_with_thread [i].second;
489
490        for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
491          {
492            // Test if link
493            if (not _link_thread_and_functionnal_unit[i][j])
494              continue;
495
496            // For each instruction :
497            //  * test if an functional_unit can execute this instruction
498            //  * test if the size data is correct
499 
500            // ORBIS
501            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ADD      ] |= (instruction_size_data(INSTRUCTION_L_ADD      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ADD      )._type][instruction_information(INSTRUCTION_L_ADD      )._operation]._latence > 0);
502            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ADDC     ] |= (instruction_size_data(INSTRUCTION_L_ADDC     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ADDC     )._type][instruction_information(INSTRUCTION_L_ADDC     )._operation]._latence > 0);
503            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ADDI     ] |= (instruction_size_data(INSTRUCTION_L_ADDI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ADDI     )._type][instruction_information(INSTRUCTION_L_ADDI     )._operation]._latence > 0);
504            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ADDIC    ] |= (instruction_size_data(INSTRUCTION_L_ADDIC    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ADDIC    )._type][instruction_information(INSTRUCTION_L_ADDIC    )._operation]._latence > 0);
505            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_AND      ] |= (instruction_size_data(INSTRUCTION_L_AND      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_AND      )._type][instruction_information(INSTRUCTION_L_AND      )._operation]._latence > 0);
506            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ANDI     ] |= (instruction_size_data(INSTRUCTION_L_ANDI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ANDI     )._type][instruction_information(INSTRUCTION_L_ANDI     )._operation]._latence > 0);
507            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_BF       ] |= (instruction_size_data(INSTRUCTION_L_BF       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_BF       )._type][instruction_information(INSTRUCTION_L_BF       )._operation]._latence > 0);
508            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_BNF      ] |= (instruction_size_data(INSTRUCTION_L_BNF      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_BNF      )._type][instruction_information(INSTRUCTION_L_BNF      )._operation]._latence > 0);
509            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CMOV     ] |= (instruction_size_data(INSTRUCTION_L_CMOV     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CMOV     )._type][instruction_information(INSTRUCTION_L_CMOV     )._operation]._latence > 0);
510//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CSYNC    ] |= (instruction_size_data(INSTRUCTION_L_CSYNC    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CSYNC    )._type][instruction_information(INSTRUCTION_L_CSYNC    )._operation]._latence > 0);
511            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST1    ] |= (instruction_size_data(INSTRUCTION_L_CUST1    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST1    )._type][instruction_information(INSTRUCTION_L_CUST1    )._operation]._latence > 0);
512            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST2    ] |= (instruction_size_data(INSTRUCTION_L_CUST2    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST2    )._type][instruction_information(INSTRUCTION_L_CUST2    )._operation]._latence > 0);
513            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST3    ] |= (instruction_size_data(INSTRUCTION_L_CUST3    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST3    )._type][instruction_information(INSTRUCTION_L_CUST3    )._operation]._latence > 0);
514            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST4    ] |= (instruction_size_data(INSTRUCTION_L_CUST4    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST4    )._type][instruction_information(INSTRUCTION_L_CUST4    )._operation]._latence > 0);
515            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST5    ] |= (instruction_size_data(INSTRUCTION_L_CUST5    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST5    )._type][instruction_information(INSTRUCTION_L_CUST5    )._operation]._latence > 0);
516            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST6    ] |= (instruction_size_data(INSTRUCTION_L_CUST6    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST6    )._type][instruction_information(INSTRUCTION_L_CUST6    )._operation]._latence > 0);
517            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST7    ] |= (instruction_size_data(INSTRUCTION_L_CUST7    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST7    )._type][instruction_information(INSTRUCTION_L_CUST7    )._operation]._latence > 0);
518            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST8    ] |= (instruction_size_data(INSTRUCTION_L_CUST8    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_CUST8    )._type][instruction_information(INSTRUCTION_L_CUST8    )._operation]._latence > 0);
519            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_DIV      ] |= (instruction_size_data(INSTRUCTION_L_DIV      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_DIV      )._type][instruction_information(INSTRUCTION_L_DIV      )._operation]._latence > 0);
520            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_DIVU     ] |= (instruction_size_data(INSTRUCTION_L_DIVU     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_DIVU     )._type][instruction_information(INSTRUCTION_L_DIVU     )._operation]._latence > 0);
521            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_EXTBS    ] |= (instruction_size_data(INSTRUCTION_L_EXTBS    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_EXTBS    )._type][instruction_information(INSTRUCTION_L_EXTBS    )._operation]._latence > 0);
522            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_EXTBZ    ] |= (instruction_size_data(INSTRUCTION_L_EXTBZ    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_EXTBZ    )._type][instruction_information(INSTRUCTION_L_EXTBZ    )._operation]._latence > 0);
523            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_EXTHS    ] |= (instruction_size_data(INSTRUCTION_L_EXTHS    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_EXTHS    )._type][instruction_information(INSTRUCTION_L_EXTHS    )._operation]._latence > 0);
524            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_EXTHZ    ] |= (instruction_size_data(INSTRUCTION_L_EXTHZ    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_EXTHZ    )._type][instruction_information(INSTRUCTION_L_EXTHZ    )._operation]._latence > 0);
525            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_EXTWS    ] |= (instruction_size_data(INSTRUCTION_L_EXTWS    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_EXTWS    )._type][instruction_information(INSTRUCTION_L_EXTWS    )._operation]._latence > 0);
526            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_EXTWZ    ] |= (instruction_size_data(INSTRUCTION_L_EXTWZ    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_EXTWZ    )._type][instruction_information(INSTRUCTION_L_EXTWZ    )._operation]._latence > 0);
527            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_FF1      ] |= (instruction_size_data(INSTRUCTION_L_FF1      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_FF1      )._type][instruction_information(INSTRUCTION_L_FF1      )._operation]._latence > 0);
528            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_FL1      ] |= (instruction_size_data(INSTRUCTION_L_FL1      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_FL1      )._type][instruction_information(INSTRUCTION_L_FL1      )._operation]._latence > 0);
529            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_J        ] |= (instruction_size_data(INSTRUCTION_L_J        ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_J        )._type][instruction_information(INSTRUCTION_L_J        )._operation]._latence > 0);
530            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_JAL      ] |= (instruction_size_data(INSTRUCTION_L_JAL      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_JAL      )._type][instruction_information(INSTRUCTION_L_JAL      )._operation]._latence > 0);
531            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_JALR     ] |= (instruction_size_data(INSTRUCTION_L_JALR     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_JALR     )._type][instruction_information(INSTRUCTION_L_JALR     )._operation]._latence > 0);
532            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_JR       ] |= (instruction_size_data(INSTRUCTION_L_JR       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_JR       )._type][instruction_information(INSTRUCTION_L_JR       )._operation]._latence > 0);
533//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LBS      ] |= (instruction_size_data(INSTRUCTION_L_LBS      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LBS      )._type][instruction_information(INSTRUCTION_L_LBS      )._operation]._latence > 0);
534//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LBZ      ] |= (instruction_size_data(INSTRUCTION_L_LBZ      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LBZ      )._type][instruction_information(INSTRUCTION_L_LBZ      )._operation]._latence > 0);
535//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LD       ] |= (instruction_size_data(INSTRUCTION_L_LD       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LD       )._type][instruction_information(INSTRUCTION_L_LD       )._operation]._latence > 0);
536//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LHS      ] |= (instruction_size_data(INSTRUCTION_L_LHS      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LHS      )._type][instruction_information(INSTRUCTION_L_LHS      )._operation]._latence > 0);
537//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LHZ      ] |= (instruction_size_data(INSTRUCTION_L_LHZ      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LHZ      )._type][instruction_information(INSTRUCTION_L_LHZ      )._operation]._latence > 0);
538//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LWS      ] |= (instruction_size_data(INSTRUCTION_L_LWS      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LWS      )._type][instruction_information(INSTRUCTION_L_LWS      )._operation]._latence > 0);
539//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LWZ      ] |= (instruction_size_data(INSTRUCTION_L_LWZ      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_LWZ      )._type][instruction_information(INSTRUCTION_L_LWZ      )._operation]._latence > 0);
540            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MAC      ] |= (instruction_size_data(INSTRUCTION_L_MAC      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MAC      )._type][instruction_information(INSTRUCTION_L_MAC      )._operation]._latence > 0);
541            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MACI     ] |= (instruction_size_data(INSTRUCTION_L_MACI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MACI     )._type][instruction_information(INSTRUCTION_L_MACI     )._operation]._latence > 0);
542            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MACRC    ] |= (instruction_size_data(INSTRUCTION_L_MACRC    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MACRC    )._type][instruction_information(INSTRUCTION_L_MACRC    )._operation]._latence > 0);
543            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MFSPR    ] |= (instruction_size_data(INSTRUCTION_L_MFSPR    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MFSPR    )._type][instruction_information(INSTRUCTION_L_MFSPR    )._operation]._latence > 0);
544            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MOVHI    ] |= (instruction_size_data(INSTRUCTION_L_MOVHI    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MOVHI    )._type][instruction_information(INSTRUCTION_L_MOVHI    )._operation]._latence > 0);
545            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MSB      ] |= (instruction_size_data(INSTRUCTION_L_MSB      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MSB      )._type][instruction_information(INSTRUCTION_L_MSB      )._operation]._latence > 0);
546//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MSYNC    ] |= (instruction_size_data(INSTRUCTION_L_MSYNC    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MSYNC    )._type][instruction_information(INSTRUCTION_L_MSYNC    )._operation]._latence > 0);
547            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MTSPR    ] |= (instruction_size_data(INSTRUCTION_L_MTSPR    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MTSPR    )._type][instruction_information(INSTRUCTION_L_MTSPR    )._operation]._latence > 0);
548            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MUL      ] |= (instruction_size_data(INSTRUCTION_L_MUL      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MUL      )._type][instruction_information(INSTRUCTION_L_MUL      )._operation]._latence > 0);
549            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MULI     ] |= (instruction_size_data(INSTRUCTION_L_MULI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MULI     )._type][instruction_information(INSTRUCTION_L_MULI     )._operation]._latence > 0);
550            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MULU     ] |= (instruction_size_data(INSTRUCTION_L_MULU     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_MULU     )._type][instruction_information(INSTRUCTION_L_MULU     )._operation]._latence > 0);
551            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_NOP      ] |= (instruction_size_data(INSTRUCTION_L_NOP      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_NOP      )._type][instruction_information(INSTRUCTION_L_NOP      )._operation]._latence > 0);
552            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_OR       ] |= (instruction_size_data(INSTRUCTION_L_OR       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_OR       )._type][instruction_information(INSTRUCTION_L_OR       )._operation]._latence > 0);
553            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ORI      ] |= (instruction_size_data(INSTRUCTION_L_ORI      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ORI      )._type][instruction_information(INSTRUCTION_L_ORI      )._operation]._latence > 0);
554//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_PSYNC    ] |= (instruction_size_data(INSTRUCTION_L_PSYNC    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_PSYNC    )._type][instruction_information(INSTRUCTION_L_PSYNC    )._operation]._latence > 0);
555            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_RFE      ] |= (instruction_size_data(INSTRUCTION_L_RFE      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_RFE      )._type][instruction_information(INSTRUCTION_L_RFE      )._operation]._latence > 0);
556            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_ROR      ] |= (instruction_size_data(INSTRUCTION_L_ROR      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_ROR      )._type][instruction_information(INSTRUCTION_L_ROR      )._operation]._latence > 0);
557            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_RORI     ] |= (instruction_size_data(INSTRUCTION_L_RORI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_RORI     )._type][instruction_information(INSTRUCTION_L_RORI     )._operation]._latence > 0);
558//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SB       ] |= (instruction_size_data(INSTRUCTION_L_SB       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SB       )._type][instruction_information(INSTRUCTION_L_SB       )._operation]._latence > 0);
559//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SD       ] |= (instruction_size_data(INSTRUCTION_L_SD       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SD       )._type][instruction_information(INSTRUCTION_L_SD       )._operation]._latence > 0);
560            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFEQ     ] |= (instruction_size_data(INSTRUCTION_L_SFEQ     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFEQ     )._type][instruction_information(INSTRUCTION_L_SFEQ     )._operation]._latence > 0);
561            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFEQI    ] |= (instruction_size_data(INSTRUCTION_L_SFEQI    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFEQI    )._type][instruction_information(INSTRUCTION_L_SFEQI    )._operation]._latence > 0);
562            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGES    ] |= (instruction_size_data(INSTRUCTION_L_SFGES    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGES    )._type][instruction_information(INSTRUCTION_L_SFGES    )._operation]._latence > 0);
563            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGESI   ] |= (instruction_size_data(INSTRUCTION_L_SFGESI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGESI   )._type][instruction_information(INSTRUCTION_L_SFGESI   )._operation]._latence > 0);
564            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGEU    ] |= (instruction_size_data(INSTRUCTION_L_SFGEU    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGEU    )._type][instruction_information(INSTRUCTION_L_SFGEU    )._operation]._latence > 0);
565            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGEUI   ] |= (instruction_size_data(INSTRUCTION_L_SFGEUI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGEUI   )._type][instruction_information(INSTRUCTION_L_SFGEUI   )._operation]._latence > 0);
566            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGTS    ] |= (instruction_size_data(INSTRUCTION_L_SFGTS    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGTS    )._type][instruction_information(INSTRUCTION_L_SFGTS    )._operation]._latence > 0);
567            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGTSI   ] |= (instruction_size_data(INSTRUCTION_L_SFGTSI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGTSI   )._type][instruction_information(INSTRUCTION_L_SFGTSI   )._operation]._latence > 0);
568            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGTU    ] |= (instruction_size_data(INSTRUCTION_L_SFGTU    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGTU    )._type][instruction_information(INSTRUCTION_L_SFGTU    )._operation]._latence > 0);
569            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFGTUI   ] |= (instruction_size_data(INSTRUCTION_L_SFGTUI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFGTUI   )._type][instruction_information(INSTRUCTION_L_SFGTUI   )._operation]._latence > 0);
570            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLES    ] |= (instruction_size_data(INSTRUCTION_L_SFLES    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLES    )._type][instruction_information(INSTRUCTION_L_SFLES    )._operation]._latence > 0);
571            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLESI   ] |= (instruction_size_data(INSTRUCTION_L_SFLESI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLESI   )._type][instruction_information(INSTRUCTION_L_SFLESI   )._operation]._latence > 0);
572            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLEU    ] |= (instruction_size_data(INSTRUCTION_L_SFLEU    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLEU    )._type][instruction_information(INSTRUCTION_L_SFLEU    )._operation]._latence > 0);
573            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLEUI   ] |= (instruction_size_data(INSTRUCTION_L_SFLEUI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLEUI   )._type][instruction_information(INSTRUCTION_L_SFLEUI   )._operation]._latence > 0);
574            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLTS    ] |= (instruction_size_data(INSTRUCTION_L_SFLTS    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLTS    )._type][instruction_information(INSTRUCTION_L_SFLTS    )._operation]._latence > 0);
575            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLTSI   ] |= (instruction_size_data(INSTRUCTION_L_SFLTSI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLTSI   )._type][instruction_information(INSTRUCTION_L_SFLTSI   )._operation]._latence > 0);
576            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLTU    ] |= (instruction_size_data(INSTRUCTION_L_SFLTU    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLTU    )._type][instruction_information(INSTRUCTION_L_SFLTU    )._operation]._latence > 0);
577            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFLTUI   ] |= (instruction_size_data(INSTRUCTION_L_SFLTUI   ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFLTUI   )._type][instruction_information(INSTRUCTION_L_SFLTUI   )._operation]._latence > 0);
578            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFNE     ] |= (instruction_size_data(INSTRUCTION_L_SFNE     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFNE     )._type][instruction_information(INSTRUCTION_L_SFNE     )._operation]._latence > 0);
579            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SFNEI    ] |= (instruction_size_data(INSTRUCTION_L_SFNEI    ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SFNEI    )._type][instruction_information(INSTRUCTION_L_SFNEI    )._operation]._latence > 0);
580//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SH       ] |= (instruction_size_data(INSTRUCTION_L_SH       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SH       )._type][instruction_information(INSTRUCTION_L_SH       )._operation]._latence > 0);
581            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SLL      ] |= (instruction_size_data(INSTRUCTION_L_SLL      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SLL      )._type][instruction_information(INSTRUCTION_L_SLL      )._operation]._latence > 0);
582            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SLLI     ] |= (instruction_size_data(INSTRUCTION_L_SLLI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SLLI     )._type][instruction_information(INSTRUCTION_L_SLLI     )._operation]._latence > 0);
583            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SRA      ] |= (instruction_size_data(INSTRUCTION_L_SRA      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SRA      )._type][instruction_information(INSTRUCTION_L_SRA      )._operation]._latence > 0);
584            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SRAI     ] |= (instruction_size_data(INSTRUCTION_L_SRAI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SRAI     )._type][instruction_information(INSTRUCTION_L_SRAI     )._operation]._latence > 0);
585            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SRL      ] |= (instruction_size_data(INSTRUCTION_L_SRL      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SRL      )._type][instruction_information(INSTRUCTION_L_SRL      )._operation]._latence > 0);
586            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SRLI     ] |= (instruction_size_data(INSTRUCTION_L_SRLI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SRLI     )._type][instruction_information(INSTRUCTION_L_SRLI     )._operation]._latence > 0);
587            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SUB      ] |= (instruction_size_data(INSTRUCTION_L_SUB      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SUB      )._type][instruction_information(INSTRUCTION_L_SUB      )._operation]._latence > 0);
588//          _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SW       ] |= (instruction_size_data(INSTRUCTION_L_SW       ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SW       )._type][instruction_information(INSTRUCTION_L_SW       )._operation]._latence > 0);
589            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SYS      ] |= (instruction_size_data(INSTRUCTION_L_SYS      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_SYS      )._type][instruction_information(INSTRUCTION_L_SYS      )._operation]._latence > 0);
590            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_TRAP     ] |= (instruction_size_data(INSTRUCTION_L_TRAP     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_TRAP     )._type][instruction_information(INSTRUCTION_L_TRAP     )._operation]._latence > 0);
591            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_XOR      ] |= (instruction_size_data(INSTRUCTION_L_XOR      ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_XOR      )._type][instruction_information(INSTRUCTION_L_XOR      )._operation]._latence > 0);
592            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_XORI     ] |= (instruction_size_data(INSTRUCTION_L_XORI     ) <= size_general_data) and (_timing[j][instruction_information(INSTRUCTION_L_XORI     )._type][instruction_information(INSTRUCTION_L_XORI     )._operation]._latence > 0);
593
594            // ORFPX
595            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_ADD_D   ] |= (instruction_size_data(INSTRUCTION_LF_ADD_D   ) <= size_general_data) and false;
596            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_ADD_S   ] |= (instruction_size_data(INSTRUCTION_LF_ADD_S   ) <= size_general_data) and false;
597            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_CUST1_D ] |= (instruction_size_data(INSTRUCTION_LF_CUST1_D ) <= size_general_data) and false;
598            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_CUST1_S ] |= (instruction_size_data(INSTRUCTION_LF_CUST1_S ) <= size_general_data) and false;
599            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_DIV_D   ] |= (instruction_size_data(INSTRUCTION_LF_DIV_D   ) <= size_general_data) and false;
600            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_DIV_S   ] |= (instruction_size_data(INSTRUCTION_LF_DIV_S   ) <= size_general_data) and false;
601            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_FTOI_D  ] |= (instruction_size_data(INSTRUCTION_LF_FTOI_D  ) <= size_general_data) and false;
602            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_FTOI_S  ] |= (instruction_size_data(INSTRUCTION_LF_FTOI_S  ) <= size_general_data) and false;
603            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_ITOF_D  ] |= (instruction_size_data(INSTRUCTION_LF_ITOF_D  ) <= size_general_data) and false;
604            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_ITOF_S  ] |= (instruction_size_data(INSTRUCTION_LF_ITOF_S  ) <= size_general_data) and false;
605            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_MADD_D  ] |= (instruction_size_data(INSTRUCTION_LF_MADD_D  ) <= size_general_data) and false;
606            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_MADD_S  ] |= (instruction_size_data(INSTRUCTION_LF_MADD_S  ) <= size_general_data) and false;
607            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_MUL_D   ] |= (instruction_size_data(INSTRUCTION_LF_MUL_D   ) <= size_general_data) and false;
608            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_MUL_S   ] |= (instruction_size_data(INSTRUCTION_LF_MUL_S   ) <= size_general_data) and false;
609            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_REM_D   ] |= (instruction_size_data(INSTRUCTION_LF_REM_D   ) <= size_general_data) and false;
610            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_REM_S   ] |= (instruction_size_data(INSTRUCTION_LF_REM_S   ) <= size_general_data) and false;
611            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFEQ_D  ] |= (instruction_size_data(INSTRUCTION_LF_SFEQ_D  ) <= size_general_data) and false;
612            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFEQ_S  ] |= (instruction_size_data(INSTRUCTION_LF_SFEQ_S  ) <= size_general_data) and false;
613            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFGE_D  ] |= (instruction_size_data(INSTRUCTION_LF_SFGE_D  ) <= size_general_data) and false;
614            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFGE_S  ] |= (instruction_size_data(INSTRUCTION_LF_SFGE_S  ) <= size_general_data) and false;
615            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFGT_D  ] |= (instruction_size_data(INSTRUCTION_LF_SFGT_D  ) <= size_general_data) and false;
616            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFGT_S  ] |= (instruction_size_data(INSTRUCTION_LF_SFGT_S  ) <= size_general_data) and false;
617            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFLE_D  ] |= (instruction_size_data(INSTRUCTION_LF_SFLE_D  ) <= size_general_data) and false;
618            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFLE_S  ] |= (instruction_size_data(INSTRUCTION_LF_SFLE_S  ) <= size_general_data) and false;
619            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFLT_D  ] |= (instruction_size_data(INSTRUCTION_LF_SFLT_D  ) <= size_general_data) and false;
620            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFLT_S  ] |= (instruction_size_data(INSTRUCTION_LF_SFLT_S  ) <= size_general_data) and false;
621            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFNE_D  ] |= (instruction_size_data(INSTRUCTION_LF_SFNE_D  ) <= size_general_data) and false;
622            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SFNE_S  ] |= (instruction_size_data(INSTRUCTION_LF_SFNE_S  ) <= size_general_data) and false;
623            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SUB_D   ] |= (instruction_size_data(INSTRUCTION_LF_SUB_D   ) <= size_general_data) and false;
624            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LF_SUB_S   ] |= (instruction_size_data(INSTRUCTION_LF_SUB_S   ) <= size_general_data) and false;
625
626            // ORVDX
627            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADD_B   ] |= (instruction_size_data(INSTRUCTION_LV_ADD_B   ) <= size_general_data) and false;
628            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADD_H   ] |= (instruction_size_data(INSTRUCTION_LV_ADD_H   ) <= size_general_data) and false;
629            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADDS_B  ] |= (instruction_size_data(INSTRUCTION_LV_ADDS_B  ) <= size_general_data) and false;
630            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADDS_H  ] |= (instruction_size_data(INSTRUCTION_LV_ADDS_H  ) <= size_general_data) and false;
631            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADDU_B  ] |= (instruction_size_data(INSTRUCTION_LV_ADDU_B  ) <= size_general_data) and false;
632            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADDU_H  ] |= (instruction_size_data(INSTRUCTION_LV_ADDU_H  ) <= size_general_data) and false;
633            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADDUS_B ] |= (instruction_size_data(INSTRUCTION_LV_ADDUS_B ) <= size_general_data) and false;
634            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ADDUS_H ] |= (instruction_size_data(INSTRUCTION_LV_ADDUS_H ) <= size_general_data) and false;
635            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_EQ_B] |= (instruction_size_data(INSTRUCTION_LV_ALL_EQ_B) <= size_general_data) and false;
636            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_EQ_H] |= (instruction_size_data(INSTRUCTION_LV_ALL_EQ_H) <= size_general_data) and false;
637            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_GE_B] |= (instruction_size_data(INSTRUCTION_LV_ALL_GE_B) <= size_general_data) and false;
638            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_GE_H] |= (instruction_size_data(INSTRUCTION_LV_ALL_GE_H) <= size_general_data) and false;
639            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_GT_B] |= (instruction_size_data(INSTRUCTION_LV_ALL_GT_B) <= size_general_data) and false;
640            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_GT_H] |= (instruction_size_data(INSTRUCTION_LV_ALL_GT_H) <= size_general_data) and false;
641            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_LE_B] |= (instruction_size_data(INSTRUCTION_LV_ALL_LE_B) <= size_general_data) and false;
642            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_LE_H] |= (instruction_size_data(INSTRUCTION_LV_ALL_LE_H) <= size_general_data) and false;
643            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_LT_B] |= (instruction_size_data(INSTRUCTION_LV_ALL_LT_B) <= size_general_data) and false;
644            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_LT_H] |= (instruction_size_data(INSTRUCTION_LV_ALL_LT_H) <= size_general_data) and false;
645            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_NE_B] |= (instruction_size_data(INSTRUCTION_LV_ALL_NE_B) <= size_general_data) and false;
646            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ALL_NE_H] |= (instruction_size_data(INSTRUCTION_LV_ALL_NE_H) <= size_general_data) and false;
647            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_AND     ] |= (instruction_size_data(INSTRUCTION_LV_AND     ) <= size_general_data) and false;
648            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_EQ_B] |= (instruction_size_data(INSTRUCTION_LV_ANY_EQ_B) <= size_general_data) and false;
649            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_EQ_H] |= (instruction_size_data(INSTRUCTION_LV_ANY_EQ_H) <= size_general_data) and false;
650            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_GE_B] |= (instruction_size_data(INSTRUCTION_LV_ANY_GE_B) <= size_general_data) and false;
651            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_GE_H] |= (instruction_size_data(INSTRUCTION_LV_ANY_GE_H) <= size_general_data) and false;
652            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_GT_B] |= (instruction_size_data(INSTRUCTION_LV_ANY_GT_B) <= size_general_data) and false;
653            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_GT_H] |= (instruction_size_data(INSTRUCTION_LV_ANY_GT_H) <= size_general_data) and false;
654            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_LE_B] |= (instruction_size_data(INSTRUCTION_LV_ANY_LE_B) <= size_general_data) and false;
655            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_LE_H] |= (instruction_size_data(INSTRUCTION_LV_ANY_LE_H) <= size_general_data) and false;
656            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_LT_B] |= (instruction_size_data(INSTRUCTION_LV_ANY_LT_B) <= size_general_data) and false;
657            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_LT_H] |= (instruction_size_data(INSTRUCTION_LV_ANY_LT_H) <= size_general_data) and false;
658            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_NE_B] |= (instruction_size_data(INSTRUCTION_LV_ANY_NE_B) <= size_general_data) and false;
659            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_ANY_NE_H] |= (instruction_size_data(INSTRUCTION_LV_ANY_NE_H) <= size_general_data) and false;
660            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_AVG_B   ] |= (instruction_size_data(INSTRUCTION_LV_AVG_B   ) <= size_general_data) and false;
661            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_AVG_H   ] |= (instruction_size_data(INSTRUCTION_LV_AVG_H   ) <= size_general_data) and false;
662            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_EQ_B] |= (instruction_size_data(INSTRUCTION_LV_CMP_EQ_B) <= size_general_data) and false;
663            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_EQ_H] |= (instruction_size_data(INSTRUCTION_LV_CMP_EQ_H) <= size_general_data) and false;
664            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_GE_B] |= (instruction_size_data(INSTRUCTION_LV_CMP_GE_B) <= size_general_data) and false;
665            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_GE_H] |= (instruction_size_data(INSTRUCTION_LV_CMP_GE_H) <= size_general_data) and false;
666            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_GT_B] |= (instruction_size_data(INSTRUCTION_LV_CMP_GT_B) <= size_general_data) and false;
667            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_GT_H] |= (instruction_size_data(INSTRUCTION_LV_CMP_GT_H) <= size_general_data) and false;
668            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_LE_B] |= (instruction_size_data(INSTRUCTION_LV_CMP_LE_B) <= size_general_data) and false;
669            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_LE_H] |= (instruction_size_data(INSTRUCTION_LV_CMP_LE_H) <= size_general_data) and false;
670            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_LT_B] |= (instruction_size_data(INSTRUCTION_LV_CMP_LT_B) <= size_general_data) and false;
671            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_LT_H] |= (instruction_size_data(INSTRUCTION_LV_CMP_LT_H) <= size_general_data) and false;
672            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_NE_B] |= (instruction_size_data(INSTRUCTION_LV_CMP_NE_B) <= size_general_data) and false;
673            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CMP_NE_H] |= (instruction_size_data(INSTRUCTION_LV_CMP_NE_H) <= size_general_data) and false;
674            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CUST1   ] |= (instruction_size_data(INSTRUCTION_LV_CUST1   ) <= size_general_data) and false;
675            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CUST2   ] |= (instruction_size_data(INSTRUCTION_LV_CUST2   ) <= size_general_data) and false;
676            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CUST3   ] |= (instruction_size_data(INSTRUCTION_LV_CUST3   ) <= size_general_data) and false;
677            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_CUST4   ] |= (instruction_size_data(INSTRUCTION_LV_CUST4   ) <= size_general_data) and false;
678            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MADDS_H ] |= (instruction_size_data(INSTRUCTION_LV_MADDS_H ) <= size_general_data) and false;
679            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MAX_B   ] |= (instruction_size_data(INSTRUCTION_LV_MAX_B   ) <= size_general_data) and false;
680            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MAX_H   ] |= (instruction_size_data(INSTRUCTION_LV_MAX_H   ) <= size_general_data) and false;
681            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MERGE_B ] |= (instruction_size_data(INSTRUCTION_LV_MERGE_B ) <= size_general_data) and false;
682            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MERGE_H ] |= (instruction_size_data(INSTRUCTION_LV_MERGE_H ) <= size_general_data) and false;
683            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MIN_B   ] |= (instruction_size_data(INSTRUCTION_LV_MIN_B   ) <= size_general_data) and false;
684            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MIN_H   ] |= (instruction_size_data(INSTRUCTION_LV_MIN_H   ) <= size_general_data) and false;
685            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MSUBS_H ] |= (instruction_size_data(INSTRUCTION_LV_MSUBS_H ) <= size_general_data) and false;
686            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_MULS_H  ] |= (instruction_size_data(INSTRUCTION_LV_MULS_H  ) <= size_general_data) and false;
687            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_NAND    ] |= (instruction_size_data(INSTRUCTION_LV_NAND    ) <= size_general_data) and false;
688            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_NOR     ] |= (instruction_size_data(INSTRUCTION_LV_NOR     ) <= size_general_data) and false;
689            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_OR      ] |= (instruction_size_data(INSTRUCTION_LV_OR      ) <= size_general_data) and false;
690            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PACK_B  ] |= (instruction_size_data(INSTRUCTION_LV_PACK_B  ) <= size_general_data) and false;
691            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PACK_H  ] |= (instruction_size_data(INSTRUCTION_LV_PACK_H  ) <= size_general_data) and false;
692            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PACKS_B ] |= (instruction_size_data(INSTRUCTION_LV_PACKS_B ) <= size_general_data) and false;
693            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PACKS_H ] |= (instruction_size_data(INSTRUCTION_LV_PACKS_H ) <= size_general_data) and false;
694            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PACKUS_B] |= (instruction_size_data(INSTRUCTION_LV_PACKUS_B) <= size_general_data) and false;
695            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PACKUS_H] |= (instruction_size_data(INSTRUCTION_LV_PACKUS_H) <= size_general_data) and false;
696            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_PERM_N  ] |= (instruction_size_data(INSTRUCTION_LV_PERM_N  ) <= size_general_data) and false;
697            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_RL_B    ] |= (instruction_size_data(INSTRUCTION_LV_RL_B    ) <= size_general_data) and false;
698            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_RL_H    ] |= (instruction_size_data(INSTRUCTION_LV_RL_H    ) <= size_general_data) and false;
699            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SLL     ] |= (instruction_size_data(INSTRUCTION_LV_SLL     ) <= size_general_data) and false;
700            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SLL_B   ] |= (instruction_size_data(INSTRUCTION_LV_SLL_B   ) <= size_general_data) and false;
701            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SLL_H   ] |= (instruction_size_data(INSTRUCTION_LV_SLL_H   ) <= size_general_data) and false;
702            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SRA_B   ] |= (instruction_size_data(INSTRUCTION_LV_SRA_B   ) <= size_general_data) and false;
703            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SRA_H   ] |= (instruction_size_data(INSTRUCTION_LV_SRA_H   ) <= size_general_data) and false;
704            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SRL     ] |= (instruction_size_data(INSTRUCTION_LV_SRL     ) <= size_general_data) and false;
705            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SRL_B   ] |= (instruction_size_data(INSTRUCTION_LV_SRL_B   ) <= size_general_data) and false;
706            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SRL_H   ] |= (instruction_size_data(INSTRUCTION_LV_SRL_H   ) <= size_general_data) and false;
707            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUB_B   ] |= (instruction_size_data(INSTRUCTION_LV_SUB_B   ) <= size_general_data) and false;
708            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUB_H   ] |= (instruction_size_data(INSTRUCTION_LV_SUB_H   ) <= size_general_data) and false;
709            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUBS_B  ] |= (instruction_size_data(INSTRUCTION_LV_SUBS_B  ) <= size_general_data) and false;
710            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUBS_H  ] |= (instruction_size_data(INSTRUCTION_LV_SUBS_H  ) <= size_general_data) and false;
711            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUBU_B  ] |= (instruction_size_data(INSTRUCTION_LV_SUBU_B  ) <= size_general_data) and false;
712            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUBU_H  ] |= (instruction_size_data(INSTRUCTION_LV_SUBU_H  ) <= size_general_data) and false;
713            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUBUS_B ] |= (instruction_size_data(INSTRUCTION_LV_SUBUS_B ) <= size_general_data) and false;
714            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_SUBUS_H ] |= (instruction_size_data(INSTRUCTION_LV_SUBUS_H ) <= size_general_data) and false;
715            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_UNPACK_B] |= (instruction_size_data(INSTRUCTION_LV_UNPACK_B) <= size_general_data) and false;
716            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_UNPACK_H] |= (instruction_size_data(INSTRUCTION_LV_UNPACK_H) <= size_general_data) and false;
717            _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_LV_XOR     ] |= (instruction_size_data(INSTRUCTION_LV_XOR     ) <= size_general_data) and false;
718          }
719
720        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST1    ] |= ;
721        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST2    ] |= ;
722        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST3    ] |= ;
723        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST4    ] |= ;
724        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST5    ] |= ;
725        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST6    ] |= ;
726        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST7    ] |= ;
727        //_front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CUST8    ] |= ;
728
729        // Test if a lsu is connected with this thread
730
731        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LBS      ] |= (instruction_size_data(INSTRUCTION_L_LBS      ) <= size_general_data);
732        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LBZ      ] |= (instruction_size_data(INSTRUCTION_L_LBZ      ) <= size_general_data);
733        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LD       ] |= (instruction_size_data(INSTRUCTION_L_LD       ) <= size_general_data);
734        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LHS      ] |= (instruction_size_data(INSTRUCTION_L_LHS      ) <= size_general_data);
735        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LHZ      ] |= (instruction_size_data(INSTRUCTION_L_LHZ      ) <= size_general_data);
736        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LWS      ] |= (instruction_size_data(INSTRUCTION_L_LWS      ) <= size_general_data);
737        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_LWZ      ] |= (instruction_size_data(INSTRUCTION_L_LWZ      ) <= size_general_data);
738
739        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SB       ] |= (instruction_size_data(INSTRUCTION_L_SB       ) <= size_general_data);
740        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SD       ] |= (instruction_size_data(INSTRUCTION_L_SD       ) <= size_general_data);
741        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SH       ] |= (instruction_size_data(INSTRUCTION_L_SH       ) <= size_general_data);
742        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_SW       ] |= (instruction_size_data(INSTRUCTION_L_SW       ) <= size_general_data);
743
744//      _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_CSYNC    ]  = true;
745        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_MSYNC    ]  = true;
746        _front_end_instruction_implemeted [num_front_end][num_context][INSTRUCTION_L_PSYNC    ]  = true;
747      }
748
749//     log_printf(TRACE,Core,FUNCTION,_("  * front_end_instruction_implemeted"));
750//     for (uint32_t i=0; i<_nb_front_end; ++i)
751//       for (uint32_t j=0; j<_nb_context[i]; ++j)
752//         for (uint32_t k=0; k<NB_INSTRUCTION; ++k)
753//           log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d] = %d - type : %d, operation : %d, size_data : %d, latence :  %d")
754//                      ,i,j,k,_front_end_instruction_implemeted[i][j][k]
755//                      ,instruction_information(k)._type
756//                      ,instruction_information(k)._operation
757//                      ,instruction_size_data(k)
758//                      ,_timing[0][instruction_information(k)._type][instruction_information(k)._operation]._latence);
759
760    // Reedit timing
761    {
762      multi_execute_loop::execute_loop::execute_timing_t timing_tmp [_nb_functionnal_unit][_nb_type][_nb_operation];
763
764      for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
765        for (uint32_t j=0; j<_nb_type; ++j)
766          for (uint32_t k=0; k<_nb_operation; ++k)
767            {
768              timing_tmp [i][j][k]._latence = _timing [i][j][k]._latence;
769              timing_tmp [i][j][k]._delay   = _timing [i][j][k]._delay  ;
770
771              // Reset
772              _timing [i][j][k]._latence = _timing [i][j][k]._delay = 0;
773            }
774
775      for (uint32_t i=0; i<_nb_thread; ++i)
776        {
777          uint32_t num_front_end = _link_context_with_thread [i].first;
778          uint32_t num_context   = _link_context_with_thread [i].second;
779         
780          for (uint32_t j=0; j<_nb_functionnal_unit; ++j)
781            {
782              // Test if link
783              if (not _link_thread_and_functionnal_unit[i][j])
784                continue;
785     
786              for (uint32_t k=0; k<NB_INSTRUCTION; ++k)
787                if (_front_end_instruction_implemeted [num_front_end][num_context][k])
788                  {
789                    uint32_t x = instruction_information(k)._type;
790                    uint32_t y = instruction_information(k)._operation;
791
792                    _timing[j][x][y]._latence = timing_tmp[j][x][y]._latence;
793                    _timing[j][x][y]._delay   = timing_tmp[j][x][y]._delay  ;
794                  }
795            }
796        } 
797    }
798   
799    ALLOC1(_front_end_nb_inst_branch_complete             ,uint32_t         ,_nb_front_end);
800    ALLOC2(_front_end_size_decod_queue                    ,uint32_t         ,_nb_front_end,_nb_decod_unit[it1]);
801    ALLOC2(_front_end_decod_queue_scheme                  ,multi_front_end::front_end::decod_unit::decod_queue::Tdecod_queue_scheme_t
802                                                                            ,_nb_front_end,_nb_decod_unit[it1]);
803    ALLOC2(_front_end_nb_inst_decod                       ,uint32_t         ,_nb_front_end,_nb_decod_unit[it1]);
804    ALLOC1(_front_end_sum_inst_decod                      ,uint32_t         ,_nb_front_end);
805    ALLOC2(_front_end_nb_context_select                   ,uint32_t         ,_nb_front_end,_nb_decod_unit[it1]);
806    ALLOC2(_front_end_context_select_priority             ,Tpriority_t      ,_nb_front_end,_nb_decod_unit[it1]);
807    ALLOC2(_front_end_context_select_load_balancing       ,Tload_balancing_t,_nb_front_end,_nb_decod_unit[it1]);
808
809    log_printf(TRACE,Core,FUNCTION,_("  * decod_unit"));
810
811    for (uint32_t i=0; i<_nb_front_end; ++i)
812      {
813        uint32_t num_rename_bloc = _link_rename_bloc_with_front_end [i];
814        uint32_t num_ooo_engine  = _link_rename_unit_with_rename_bloc [num_rename_bloc].first;
815
816        _front_end_nb_inst_branch_complete [i] = _nb_inst_branch_complete [num_ooo_engine];
817        _front_end_sum_inst_decod          [i] = 0;
818        for (uint32_t j=0; j<_nb_decod_unit[i]; ++j)
819          {
820            uint32_t num_decod_bloc=_link_decod_bloc_with_decod_unit[i][j];
821           
822            log_printf(TRACE,Core,FUNCTION,_("  [%d][%d] -> %d"),i,j,num_decod_bloc);
823 
824            _front_end_size_decod_queue              [i][j] = _size_decod_queue              [num_decod_bloc];
825            _front_end_decod_queue_scheme            [i][j] = _decod_queue_scheme            [num_decod_bloc];
826            _front_end_nb_inst_decod                 [i][j] = _nb_inst_decod                 [num_decod_bloc];
827            _front_end_sum_inst_decod                [i]   += _nb_inst_decod                 [num_decod_bloc];
828            _front_end_nb_context_select             [i][j] = _nb_context_select             [num_decod_bloc];
829            _front_end_context_select_priority       [i][j] = _context_select_priority       [num_decod_bloc];
830            _front_end_context_select_load_balancing [i][j] = _context_select_load_balancing [num_decod_bloc];
831          }
832      }
833
834    ALLOC1(_ooo_engine_nb_front_end                       ,uint32_t         ,_nb_ooo_engine);
835
836    log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_nb_front_end"));
837   
838    {
839      std::vector<uint32_t> list_front_end [_nb_ooo_engine];
840
841      // initialization counter
842      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
843        _ooo_engine_nb_front_end [i] = 0;
844
845      // scan all front_end
846      for (uint32_t i=0; i<_nb_front_end; ++i)
847        {
848          uint32_t num_rename_bloc = _link_rename_bloc_with_front_end [i];
849          uint32_t num_ooo_engine  = _link_rename_unit_with_rename_bloc [num_rename_bloc].first;
850       
851          log_printf(TRACE,Core,FUNCTION,_("    * num_front_end             : %d"),i);
852          log_printf(TRACE,Core,FUNCTION,_("      * num_rename_bloc         : %d"),num_rename_bloc);
853          log_printf(TRACE,Core,FUNCTION,_("      * num_ooo_engine          : %d"),num_ooo_engine );
854          log_printf(TRACE,Core,FUNCTION,_("      * ooo_engine_nb_front_end : %d"),_ooo_engine_nb_front_end [num_ooo_engine]);
855           // insert a new front_end
856          _ooo_engine_nb_front_end [num_ooo_engine] ++; // === list_front_end.size()
857          list_front_end           [num_ooo_engine].push_back(i); // No double
858        }
859
860      log_printf(TRACE,Core,FUNCTION,_("  * translate_ooo_engine_num_front_end"));
861     
862      ALLOC2(_translate_ooo_engine_num_front_end            ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
863      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
864        {
865//           log_printf(TRACE,Core,FUNCTION,_("   %d -> %d"),i,_ooo_engine_nb_front_end[i]);
866             
867          for (uint32_t j=0; j<_ooo_engine_nb_front_end[i] ;++j)
868            {
869              uint32_t num_front_end = list_front_end[i][j];
870           
871              log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> %d"),i,j,num_front_end);
872             
873              _translate_ooo_engine_num_front_end [i][j] = num_front_end;
874            }
875        }
876    }
877
878    ALLOC1(_ooo_engine_nb_execute_loop                    ,uint32_t         ,_nb_ooo_engine);
879
880    {
881      std::vector<uint32_t> list_execute_loop [_nb_ooo_engine];
882
883      // initialization counter
884      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
885        _ooo_engine_nb_execute_loop [i] = 0;
886
887      // scan the dispatch table
888      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
889        {
890          for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
891            for (uint32_t k=0; k<_nb_read_bloc; ++k)
892              {
893                // have route between this slot's ooo_engine and an read_bloc
894                if (_table_dispatch [i][j][k])
895                  {
896                    uint32_t num_execute_loop = _link_read_unit_with_read_bloc [k].first;
897                   
898                    list_execute_loop[i].push_back(num_execute_loop);
899                  }
900              }
901               
902          {
903            sort  (list_execute_loop[i].begin(),
904                   list_execute_loop[i].end());
905            std::vector<uint32_t>::iterator it=std::unique(list_execute_loop[i].begin(),
906                                                           list_execute_loop[i].end());
907            list_execute_loop[i].erase(it,list_execute_loop[i].end());
908          }
909
910          _ooo_engine_nb_execute_loop [i] = list_execute_loop[i].size();
911        }
912
913      log_printf(TRACE,Core,FUNCTION,_("  * translate_ooo_engine_num_execute_loop"));
914     
915      ALLOC2(_translate_ooo_engine_num_execute_loop         ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_execute_loop[it1]);
916
917      for (uint32_t i=0; i<_nb_ooo_engine; ++i)
918        for (uint32_t j=0; j<list_execute_loop[i].size();++j)
919          {
920            uint32_t num_execute_loop = list_execute_loop[i][j];
921
922            log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> %d"),i,j,num_execute_loop);
923            _translate_ooo_engine_num_execute_loop [i][j++] = num_execute_loop;
924          }
925    }
926
927    ALLOC2(_ooo_engine_nb_context                         ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
928    ALLOC2(_ooo_engine_nb_inst_decod                      ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
929
930    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
931      for (uint32_t j=0; j<_ooo_engine_nb_front_end[i]; ++j)
932        {
933          uint32_t num_front_end = _translate_ooo_engine_num_front_end [i][j];
934
935          _ooo_engine_nb_context    [i][j] = _nb_context [num_front_end];
936          _ooo_engine_nb_inst_decod [i][j] = 0;
937
938          // All context is route to the same rename_unit
939          for (uint32_t k=0; k<_nb_decod_unit[num_front_end]; ++k)
940            _ooo_engine_nb_inst_decod [i][j] += _front_end_nb_inst_decod [num_front_end][k];
941        }
942
943    ALLOC3(_ooo_engine_translate_num_context_to_num_thread,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2]);
944    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
945      for (uint32_t j=0; j<_ooo_engine_nb_front_end[i]; ++j)
946        {
947          uint32_t num_front_end = _translate_ooo_engine_num_front_end [i][j];
948          for (uint32_t k=0; k<_ooo_engine_nb_context[i][j]; ++k)
949            {
950              uint32_t num_thread = _link_thread_with_context[num_front_end][k];
951
952              _ooo_engine_translate_num_context_to_num_thread [i][j][k] = num_thread;
953            }
954        }
955
956    ALLOC2(_ooo_engine_nb_inst_execute                    ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_execute_loop[it1]);
957
958    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
959      for (uint32_t j=0; j<_ooo_engine_nb_execute_loop[i]; ++j)
960        {
961          uint32_t num_execute_loop = _translate_ooo_engine_num_execute_loop [i][j];
962
963          // each write_unit manage one instruction per cycle.
964          _ooo_engine_nb_inst_execute [i][j] = _nb_write_unit [num_execute_loop];
965        }
966   
967    ALLOC3(_ooo_engine_nb_branch_speculated               ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2]);
968    ALLOC2(_ooo_engine_link_rename_unit_with_front_end    ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
969
970    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
971      for (uint32_t j=0; j<_ooo_engine_nb_front_end[i]; ++j)
972        {
973          uint32_t num_front_end = _translate_ooo_engine_num_front_end [i][j];
974
975          for (uint32_t k=0; k<_nb_context[num_front_end];++k)
976            {
977              uint32_t num_thread = _link_thread_with_context[num_front_end][k];
978
979              _ooo_engine_nb_branch_speculated [i][j][k] = _upt_size_queue [num_thread];
980            }
981         
982          uint32_t num_rename_bloc = _link_rename_bloc_with_front_end  [num_front_end];
983          uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc[num_rename_bloc].second; 
984
985          _ooo_engine_link_rename_unit_with_front_end [i][j] = num_rename_unit;
986        }
987
988    ALLOC2(_ooo_engine_nb_inst_insert                     ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
989    ALLOC1(_ooo_engine_nb_inst_insert_rob                 ,uint32_t         ,_nb_ooo_engine);
990    ALLOC2(_ooo_engine_nb_inst_retire                     ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
991    ALLOC2(_ooo_engine_rename_select_priority             ,Tpriority_t      ,_nb_ooo_engine,_nb_rename_unit[it1]);
992    ALLOC2(_ooo_engine_rename_select_load_balancing       ,Tload_balancing_t,_nb_ooo_engine,_nb_rename_unit[it1]);
993    ALLOC2(_ooo_engine_rename_select_nb_front_end_select  ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
994    ALLOC2(_ooo_engine_nb_general_register                ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
995    ALLOC2(_ooo_engine_nb_special_register                ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
996    ALLOC2(_ooo_engine_nb_reg_free                        ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
997    ALLOC2(_ooo_engine_nb_rename_unit_bank                ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
998//     ALLOC2(_ooo_engine_size_read_counter                  ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
999
1000    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1001      {
1002        log_printf(TRACE,Core,FUNCTION,_("OOO_Engine [%d] - nb_rename_unit %d"),i,_nb_rename_unit[i]);
1003        _ooo_engine_nb_inst_insert_rob [i] = 0;
1004
1005        for (uint32_t j=0; j<_nb_rename_unit[i]; ++j)
1006          {
1007            uint32_t num_rename_bloc = _link_rename_bloc_with_rename_unit [i][j];
1008
1009            log_printf(TRACE,Core,FUNCTION,_("  * [%d] - num_rename_bloc %d, nb_inst_insert %d"),j,num_rename_bloc,_nb_inst_insert[num_rename_bloc]);
1010           
1011            _ooo_engine_nb_inst_insert                    [i][j] = _nb_inst_insert                    [num_rename_bloc];
1012            _ooo_engine_nb_inst_insert_rob                [i]   += _nb_inst_insert                    [num_rename_bloc];
1013            _ooo_engine_nb_inst_retire                    [i][j] = _nb_inst_retire                    [num_rename_bloc];
1014            _ooo_engine_rename_select_priority            [i][j] = _rename_select_priority            [num_rename_bloc];
1015            _ooo_engine_rename_select_load_balancing      [i][j] = _rename_select_load_balancing      [num_rename_bloc];
1016            _ooo_engine_rename_select_nb_front_end_select [i][j] = _rename_select_nb_front_end_select [num_rename_bloc];
1017            _ooo_engine_nb_general_register               [i][j] = _nb_general_register               [num_rename_bloc];
1018            _ooo_engine_nb_special_register               [i][j] = _nb_special_register               [num_rename_bloc];
1019            _ooo_engine_nb_reg_free                       [i][j] = _nb_reg_free                       [num_rename_bloc];
1020            _ooo_engine_nb_rename_unit_bank               [i][j] = _nb_rename_unit_bank               [num_rename_bloc];
1021//             _ooo_engine_size_read_counter                 [i][j] = _size_read_counter                 [num_rename_bloc];
1022          }
1023      }
1024   
1025    ALLOC4(_network_table_dispatch                        ,bool             ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_execute_loop,_nb_read_unit[it3]);
1026//  ALLOC3(_ooo_engine_table_routing                      ,bool             ,_nb_ooo_engine,_nb_rename_unit[it1],_nb_inst_issue_slot[it1]);
1027//  ALLOC3(_ooo_engine_table_issue_type                   ,bool             ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_type);
1028    ALLOC2(_list_functionnal_unit_with_rename_unit        ,std::vector<uint32_t>,_nb_ooo_engine,_nb_rename_unit[it1]);
1029    ALLOC2(_list_load_store_unit_with_rename_unit         ,std::vector<uint32_t>,_nb_ooo_engine,_nb_rename_unit[it1]);
1030
1031    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1032      {
1033//         log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_table_issue_type [%d]"),i);
1034
1035        // Init
1036        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
1037          {
1038            for (uint32_t k=0; k<_nb_execute_loop; ++k)
1039              for (uint32_t l=0; l<_nb_read_unit[k]; ++l)
1040                _network_table_dispatch [i][j][k][l] = false;
1041//             for (uint32_t k=0; k<_nb_rename_unit[i]; ++k)
1042//               _ooo_engine_table_routing [i][k][j] = false;
1043//             for (uint32_t k=0; k<_nb_type; ++k)
1044//               _ooo_engine_table_issue_type [i][j][k] = false;
1045          }
1046
1047        std::vector<uint32_t> list_thread_with_inst_issue [_nb_inst_issue_slot[i]];
1048       
1049        for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
1050          {
1051            for (uint32_t k=0; k<_nb_read_bloc; ++k)
1052              // Test if the issue slot is linked with the read_bloc
1053              if (_table_dispatch[i][j][k])
1054                {
1055                  pair_dual x = _link_read_unit_with_read_bloc[k];
1056                  _network_table_dispatch [i][j][x.first][x.second] = true;
1057
1058                  // Test functional unit connected with this read bloc
1059                  for (uint32_t l=0; l<_nb_functionnal_unit; ++l)
1060                    {
1061                      // the issue slot [j] is connected with the read bloc [k] and it's connected with the functionnal_unit [l]
1062                      if (_link_read_bloc_and_functionnal_unit [k][l])
1063                        {
1064                          // Scan timing table, test if have an instruction
1065//                           for (uint32_t m=0; m<_nb_type; ++m)
1066//                             for (uint32_t n=0; n<_nb_operation; ++n)
1067//                               if (_timing[l][m][n]._latence > 0)
1068//                                 {
1069//                                   log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> true"),j,m);
1070                                 
1071//                                   _ooo_engine_table_issue_type [i][j][m] = true;
1072//                                   break;
1073//                                 }
1074                         
1075                          for (uint32_t m=0; m<_nb_thread; ++m)
1076                            {
1077                              list_thread_with_inst_issue [j].push_back(m);
1078                             
1079                              uint32_t num_front_end   = _link_context_with_thread [m].first;
1080                              uint32_t num_rename_bloc = _link_rename_bloc_with_front_end[num_front_end];
1081                              uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
1082                             
1083                              _list_functionnal_unit_with_rename_unit [i][num_rename_unit].push_back(l);
1084                            }
1085                        }
1086                    }
1087
1088                  // Test load store unit connected with this read bloc
1089                  for (uint32_t l=0; l<_nb_load_store_unit; ++l)
1090                    {
1091                      // Test load store unit connected with this read bloc
1092                      if (_link_read_bloc_and_load_store_unit [k][l])
1093                       {
1094//                        _ooo_engine_table_issue_type [i][j][TYPE_MEMORY] = true;
1095//                        _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);
1096//                        _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);
1097//                        _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);
1098//                        _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);
1099//                        _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);
1100//                        _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);
1101//                        _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);
1102//                        _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);
1103//                        _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);
1104//                        _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);
1105//                        _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);
1106
1107                          // the issue slot [j] is connected with the read bloc [k] and it's connected with the load_store_unit [l]
1108                          for (uint32_t m=0; m<_nb_thread; ++m)
1109                            {
1110                              list_thread_with_inst_issue [j].push_back(m);
1111                             
1112                              uint32_t num_front_end   = _link_context_with_thread [m].first;
1113                              uint32_t num_rename_bloc = _link_rename_bloc_with_front_end[num_front_end];
1114                              uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
1115                             
1116                              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);
1117
1118                              _list_load_store_unit_with_rename_unit [i][num_rename_unit].push_back(l);
1119                            }
1120                        }
1121                    }
1122                }
1123            // sort and erase duplicate value
1124            {
1125              sort  (list_thread_with_inst_issue [j].begin(),
1126                     list_thread_with_inst_issue [j].end());
1127              std::vector<uint32_t>::iterator it=unique(list_thread_with_inst_issue [j].begin(),
1128                                                        list_thread_with_inst_issue [j].end());
1129              list_thread_with_inst_issue [j].erase(it,list_thread_with_inst_issue [j].end());
1130            }
1131          }
1132
1133        log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_table_routing [%d]"),i);
1134        for (uint32_t j=0; j<_nb_rename_unit[i]; ++j)
1135          {
1136            // sort and erase duplicate value
1137            {
1138              sort  (_list_load_store_unit_with_rename_unit  [i][j].begin(),
1139                     _list_load_store_unit_with_rename_unit  [i][j].end());
1140              std::vector<uint32_t>::iterator it=unique(_list_load_store_unit_with_rename_unit  [i][j].begin(),
1141                                                        _list_load_store_unit_with_rename_unit  [i][j].end());
1142              _list_load_store_unit_with_rename_unit  [i][j].erase(it,_list_load_store_unit_with_rename_unit  [i][j].end());
1143            }
1144            {
1145              sort  (_list_functionnal_unit_with_rename_unit  [i][j].begin(),
1146                     _list_functionnal_unit_with_rename_unit  [i][j].end());
1147              std::vector<uint32_t>::iterator it=unique(_list_functionnal_unit_with_rename_unit  [i][j].begin(),
1148                                                        _list_functionnal_unit_with_rename_unit  [i][j].end());
1149              _list_functionnal_unit_with_rename_unit  [i][j].erase(it,_list_functionnal_unit_with_rename_unit  [i][j].end());
1150            }
1151
1152//             uint32_t num_rename_bloc = _link_rename_bloc_with_rename_unit[i][j];
1153
1154//             for (uint32_t k=0; k<_nb_front_end; ++k)
1155//               // test if this front_end is connected with this rename_bloc
1156//               if (_link_rename_bloc_with_front_end[k] == num_rename_bloc)
1157//                 // the front end is connected with rename_bloc. Now test all slot issue that it can accepted this front_end
1158//                 for (uint32_t l=0; l<_nb_inst_issue_slot[i]; ++l)
1159//                   for (std::vector<uint32_t>::iterator it = list_thread_with_inst_issue [l].begin();
1160//                        it != list_thread_with_inst_issue [l].end();
1161//                        ++it)
1162//                     // Test if the this is in front_end [k]
1163//                     if (_link_context_with_thread[*it].first == k)
1164//                       {
1165//                         _ooo_engine_table_routing [i][j][l] |= true;
1166//                         log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> true"),j,l);
1167//                       }
1168          }
1169      }
1170   
1171    log_printf(TRACE,Core,FUNCTION,_("  * network_table_dispatch [nb_ooo_engine][nb_inst_issue_slot][nb_execute_loop][nb_read_unit]"));
1172    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1173      for (uint32_t j=0; j<_nb_inst_issue_slot[i]; ++j)
1174        for (uint32_t k=0; k<_nb_execute_loop; ++k)
1175          for (uint32_t l=0; l<_nb_read_unit[k]; ++l)
1176            if (_network_table_dispatch [i][j][k][l] == true)
1177              log_printf(TRACE,Core,FUNCTION,_("   Issue Slot [%d][%d] is connected with Read_unit [%d][%d]"),i,j,k,l);
1178
1179    ALLOC3(_network_table_issue_type,bool,_nb_execute_loop,_nb_read_unit[it1],_nb_type);
1180
1181    log_printf(TRACE,Core,FUNCTION,_("  * network_table_issue_type"));
1182    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1183      for (uint32_t j=0; j<_nb_read_unit[i]; ++j)
1184        {
1185          // init
1186          for (uint32_t t=0; t<_nb_type; ++t)
1187            _network_table_issue_type [i][j][t] = false;
1188
1189          // get number of read bloc
1190          uint32_t num_read_bloc = _link_read_bloc_with_read_unit[i][j];
1191
1192          // for each functionnal unit : test if the read bloc is connected with the functionnal unit
1193          for (uint32_t k=0; k<_nb_functionnal_unit; ++k)
1194            if (_link_read_bloc_and_functionnal_unit [num_read_bloc][k])
1195              // Scan timing table, test if have an instruction
1196              for (uint32_t t=0; t<_nb_type; ++t)
1197                for (uint32_t o=0; o<_nb_operation; ++o)
1198                  if (_timing[k][t][o]._latence > 0)
1199                    {
1200                      log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d] -> true"),i,j,t);
1201                     
1202                      _network_table_issue_type [i][j][t] = true;
1203                      break; // operation
1204                    }
1205         
1206          // Test load store unit connected with this read bloc
1207          for (uint32_t k=0; k<_nb_load_store_unit; ++k)
1208            // Test load store unit connected with this read bloc
1209            if (_link_read_bloc_and_load_store_unit [num_read_bloc][k])
1210              {
1211                uint32_t t = TYPE_MEMORY;
1212               
1213                log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d] -> true"),i,j,t);
1214               
1215                _network_table_issue_type [i][j][t] = true;
1216                break; // load_store_unit
1217              }
1218        }
1219
1220    ALLOC2(_ooo_engine_nb_load_store_unit                 ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1]);
1221
1222    log_printf(TRACE,Core,FUNCTION,_("  * ooo_engine_nb_load_store_unit [nb_ooo_engine][nb_rename_unit]"));
1223    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1224      for (uint32_t j=0; j<_nb_rename_unit[i]; ++j)
1225        {
1226          _ooo_engine_nb_load_store_unit [i][j] = _list_load_store_unit_with_rename_unit [i][j].size();
1227          log_printf(TRACE,Core,FUNCTION,_("    [%d][%d] = %d"),i,j,_ooo_engine_nb_load_store_unit [i][j]);
1228        }
1229
1230    ALLOC3(_ooo_engine_size_store_queue                   ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1],_ooo_engine_nb_load_store_unit[it1][it2]);
1231    ALLOC3(_ooo_engine_size_load_queue                    ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1],_ooo_engine_nb_load_store_unit[it1][it2]);
1232    ALLOC3(_ooo_engine_nb_inst_memory                     ,uint32_t         ,_nb_ooo_engine,_nb_rename_unit[it1],_ooo_engine_nb_load_store_unit[it1][it2]);
1233    ALLOC3(_ooo_engine_link_load_store_unit_with_context  ,uint32_t         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2]);
1234   
1235    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1236      {
1237        for (uint32_t j=0; j<_nb_rename_unit[i]; ++j)
1238          for (uint32_t k=0; k<_list_load_store_unit_with_rename_unit [i][j].size(); ++k)
1239            {
1240              uint32_t num_load_store_unit = _list_load_store_unit_with_rename_unit[i][j][k];
1241             
1242              _ooo_engine_size_store_queue [i][j][k] = _size_store_queue[num_load_store_unit];
1243              _ooo_engine_size_load_queue  [i][j][k] = _size_load_queue [num_load_store_unit];
1244              _ooo_engine_nb_inst_memory   [i][j][k] = _nb_inst_memory  [num_load_store_unit];
1245            }
1246
1247        for (uint32_t j=0; j<_ooo_engine_nb_front_end[i]; ++j)
1248          {
1249            uint32_t num_front_end   = _translate_ooo_engine_num_front_end [i][j];
1250            uint32_t num_rename_bloc = _link_rename_bloc_with_front_end [num_front_end];
1251            uint32_t num_rename_unit = _link_rename_unit_with_rename_bloc [num_rename_bloc].second;
1252
1253            std::vector<uint32_t> list_lsq = _list_load_store_unit_with_rename_unit[i][num_rename_unit];
1254
1255            for (uint32_t k=0; k<_ooo_engine_nb_context[i][j]; ++k)
1256              {
1257                uint32_t num_thread          = _link_thread_with_context [num_front_end][k];
1258                uint32_t num_load_store_unit = _link_load_store_unit_with_thread [num_thread];
1259                uint32_t num_lsq;
1260
1261                // Find correspondence between load_store_unit and num_load_store_unit in rename_unit
1262                for (num_lsq=0; num_lsq<list_lsq.size(); ++num_lsq)
1263                  if (list_lsq[num_lsq] == num_load_store_unit)
1264                    break;
1265#ifdef DEBUG_TEST
1266                if (num_lsq == list_lsq.size())
1267                  throw ERRORMORPHEO(FUNCTION,_("Load Store Unit search failed."));
1268#endif
1269               
1270                _ooo_engine_link_load_store_unit_with_context [i][j][k] = num_lsq;
1271              }
1272          }
1273      }
1274
1275    ALLOC4(_ooo_engine_implement_group                    ,bool             ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2],NB_GROUP);
1276
1277    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1278      for (uint32_t j=0; j<_ooo_engine_nb_front_end[i]; ++j)
1279        {
1280          uint32_t num_front_end = _translate_ooo_engine_num_front_end [i][j];
1281         
1282          for (uint32_t k=0; k<_ooo_engine_nb_context[i][j]; ++k)
1283            {
1284              uint32_t num_thread    = _link_thread_with_context [num_front_end][k];
1285           
1286              for (uint32_t l=0; l<NB_GROUP; ++l)
1287                _ooo_engine_implement_group [i][j][k][l] = false;
1288             
1289              _ooo_engine_implement_group [i][j][k][GROUP_SYSTEM_AND_CONTROL ] = true ; // always implemented
1290              _ooo_engine_implement_group [i][j][k][GROUP_DMMU               ] = false; // not yet implemented
1291              _ooo_engine_implement_group [i][j][k][GROUP_IMMU               ] = false; // not yet implemented
1292              _ooo_engine_implement_group [i][j][k][GROUP_DCACHE             ] = _implement_group [num_thread][GROUP_DCACHE];
1293              _ooo_engine_implement_group [i][j][k][GROUP_ICACHE             ] = false; // not yet implemented
1294              _ooo_engine_implement_group [i][j][k][GROUP_MAC                ] = 
1295                (_front_end_instruction_implemeted [num_front_end][k][INSTRUCTION_L_MAC  ] or
1296                 _front_end_instruction_implemeted [num_front_end][k][INSTRUCTION_L_MACI ] or
1297                 _front_end_instruction_implemeted [num_front_end][k][INSTRUCTION_L_MACRC] or
1298                 _front_end_instruction_implemeted [num_front_end][k][INSTRUCTION_L_MSB  ] );
1299              _ooo_engine_implement_group [i][j][k][GROUP_DEBUG              ] = false; // not yet implemented
1300              _ooo_engine_implement_group [i][j][k][GROUP_PERFORMANCE_COUNTER] = false; // not yet implemented
1301              _ooo_engine_implement_group [i][j][k][GROUP_POWER_MANAGEMENT   ] = false; // not yet implemented
1302              _ooo_engine_implement_group [i][j][k][GROUP_PIC                ] = false; // not yet implemented
1303              _ooo_engine_implement_group [i][j][k][GROUP_TICK_TIMER         ] = false; // not yet implemented
1304              _ooo_engine_implement_group [i][j][k][GROUP_FLOATING_POINT     ] = false; // not yet implemented
1305              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_1         ] = false; // reserved
1306              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_2         ] = false; // reserved
1307              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_3         ] = false; // reserved
1308              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_4         ] = false; // reserved
1309              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_5         ] = false; // reserved
1310              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_6         ] = false; // reserved
1311              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_7         ] = false; // reserved
1312              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_8         ] = false; // reserved
1313              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_9         ] = false; // reserved
1314              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_10        ] = false; // reserved
1315              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_11        ] = false; // reserved
1316              _ooo_engine_implement_group [i][j][k][GROUP_RESERVED_12        ] = false; // reserved
1317             
1318              bool have_custom_unit = (_get_custom_information != NULL);
1319
1320              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_1           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_1));
1321              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_2           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_2));
1322              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_3           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_3));
1323              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_4           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_4));
1324              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_5           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_5));
1325              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_6           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_6));
1326              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_7           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_7));
1327              _ooo_engine_implement_group [i][j][k][GROUP_CUSTOM_8           ] = (have_custom_unit and _get_custom_information()._get_valid_group(GROUP_CUSTOM_8));
1328            }
1329        }
1330
1331    ALLOC1(_execute_loop_nb_functionnal_unit                       ,uint32_t,_nb_execute_loop);
1332    ALLOC1(_execute_loop_nb_load_store_unit                        ,uint32_t,_nb_execute_loop);
1333
1334    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1335      {
1336        _execute_loop_nb_functionnal_unit [i] = _list_functionnal_unit_with_execute_unit [i].size();
1337        _execute_loop_nb_load_store_unit  [i] = _list_load_store_unit_with_execute_unit  [i].size();
1338      }
1339   
1340    ALLOC1(_list_ooo_engine_with_execute_loop                      ,std::vector<uint32_t>,_nb_execute_loop);
1341    ALLOC1(_list_front_end_with_execute_loop                       ,std::vector<uint32_t>,_nb_execute_loop);
1342   
1343    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1344      {
1345        for (uint32_t j=0; j<_ooo_engine_nb_execute_loop[i]; ++j)
1346          {
1347            uint32_t num_execute_loop = _translate_ooo_engine_num_execute_loop [i][j];
1348           
1349            _list_ooo_engine_with_execute_loop [num_execute_loop].push_back(i);
1350   
1351            for (uint32_t k=0; k<_ooo_engine_nb_front_end[i]; ++k)
1352              {
1353                uint32_t num_front_end = _translate_ooo_engine_num_front_end [i][k];
1354               
1355                _list_front_end_with_execute_loop [num_execute_loop].push_back(num_front_end);
1356              }
1357          }
1358      }
1359   
1360    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1361      {
1362        {
1363          sort  (_list_ooo_engine_with_execute_loop[i].begin(),
1364                 _list_ooo_engine_with_execute_loop[i].end());
1365          std::vector<uint32_t>::iterator it=unique(_list_ooo_engine_with_execute_loop[i].begin(),
1366                                                    _list_ooo_engine_with_execute_loop[i].end());
1367          _list_ooo_engine_with_execute_loop[i].erase(it,_list_ooo_engine_with_execute_loop[i].end());
1368        }
1369        {
1370          sort  (_list_front_end_with_execute_loop[i].begin(),
1371                 _list_front_end_with_execute_loop[i].end());
1372          std::vector<uint32_t>::iterator it=unique(_list_front_end_with_execute_loop[i].begin(),
1373                                                    _list_front_end_with_execute_loop[i].end());
1374          _list_front_end_with_execute_loop[i].erase(it,_list_front_end_with_execute_loop[i].end());
1375        }
1376      }
1377
1378
1379#if (DEBUG >= DEBUG_TRACE)
1380
1381    log_printf(TRACE,Core,FUNCTION,_("list_ooo_engine_with_execute_loop"));
1382    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1383      for (uint32_t j=0; j<_list_ooo_engine_with_execute_loop[i].size(); ++j)
1384        log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> %d"),i,j,_list_ooo_engine_with_execute_loop[i][j]);
1385   
1386    log_printf(TRACE,Core,FUNCTION,_("list_front_end_with_execute_loop"));
1387    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1388      for (uint32_t j=0; j<_list_front_end_with_execute_loop[i].size(); ++j)
1389        log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> %d"),i,j,_list_front_end_with_execute_loop[i][j]);
1390
1391#endif
1392
1393    ALLOC1(_execute_loop_nb_front_end                              ,uint32_t,_nb_execute_loop);
1394    ALLOC1(_execute_loop_nb_context                                ,uint32_t,_nb_execute_loop);
1395    ALLOC1(_execute_loop_nb_ooo_engine                             ,uint32_t,_nb_execute_loop);
1396    ALLOC1(_execute_loop_nb_packet                                 ,uint32_t,_nb_execute_loop);
1397    ALLOC1(_execute_loop_nb_thread                                 ,uint32_t,_nb_execute_loop);
1398   
1399    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1400      {
1401        log_printf(TRACE,Core,FUNCTION,_("execute_loop [%d] information :"),i);
1402   
1403        _execute_loop_nb_ooo_engine [i] = _list_ooo_engine_with_execute_loop[i].size();
1404   
1405        log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_nb_ooo_engine : %d"),_execute_loop_nb_ooo_engine [i]);
1406   
1407        uint32_t max_nb_front_end = 0;
1408        uint32_t max_nb_context   = 0;
1409        uint32_t max_size_rob     = 0;
1410   
1411        for (std::vector<uint32_t>::iterator it=_list_ooo_engine_with_execute_loop[i].begin();
1412             it!=_list_ooo_engine_with_execute_loop[i].end();
1413             ++it)
1414          {
1415            uint32_t num_ooo_engine = *it;
1416   
1417            max_size_rob     = std::max(max_size_rob,_size_re_order_buffer[num_ooo_engine]);
1418            max_nb_front_end = std::max(max_nb_front_end,_ooo_engine_nb_front_end[num_ooo_engine]);
1419   
1420            for (uint32_t j=0; j<_ooo_engine_nb_front_end[num_ooo_engine]; ++j)
1421              {
1422                uint32_t num_front_end = _translate_ooo_engine_num_front_end [num_ooo_engine][j];
1423   
1424                max_nb_context = std::max(max_nb_context,_nb_context[num_front_end]);
1425              }
1426          }
1427        _execute_loop_nb_front_end  [i] = max_nb_front_end;
1428        _execute_loop_nb_context    [i] = max_nb_context  ;
1429        _execute_loop_nb_packet     [i] = max_size_rob    ;
1430   
1431        log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_nb_front_end  : %d"),_execute_loop_nb_front_end  [i]);
1432        log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_nb_context    : %d"),_execute_loop_nb_context    [i]);
1433        log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_nb_packet     : %d"),_execute_loop_nb_packet     [i]);
1434   
1435        _execute_loop_nb_thread     [i] = get_nb_thread(_execute_loop_nb_context    [i],
1436                                                        _execute_loop_nb_front_end  [i],
1437                                                        _execute_loop_nb_ooo_engine [i]);
1438   
1439        log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_nb_thread     : %d"),_execute_loop_nb_thread     [i]);
1440      }
1441   
1442    ALLOC2(_translate_execute_loop_num_ooo_engine                  ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
1443    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1444      for (uint32_t j=0; j<_execute_loop_nb_ooo_engine[i]; ++j)
1445        {
1446          _translate_execute_loop_num_ooo_engine [i][j] = _list_ooo_engine_with_execute_loop[i][j];
1447        } 
1448   
1449    ALLOC2(_execute_loop_size_read_queue                           ,uint32_t,_nb_execute_loop,_nb_read_unit[it1]);
1450    ALLOC2(_execute_loop_size_reservation_station                  ,uint32_t,_nb_execute_loop,_nb_read_unit[it1]);
1451    ALLOC2(_execute_loop_nb_inst_retire                            ,uint32_t,_nb_execute_loop,_nb_read_unit[it1]);
1452   
1453    log_printf(TRACE,Core,FUNCTION,_("  * execute_loop - Read_unit"));
1454    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1455      {
1456        log_printf(TRACE,Core,FUNCTION,_("    * [%d] nb_read_unit : %d"),i,_nb_read_unit[i]);
1457       
1458        for (uint32_t j=0; j<_nb_read_unit[i]; ++j)
1459          {
1460            uint32_t num_read_bloc = _link_read_bloc_with_read_unit [i][j];
1461
1462            log_printf(TRACE,Core,FUNCTION,_("      * num_read_bloc : %d"),num_read_bloc);
1463           
1464            _execute_loop_size_read_queue          [i][j] = _size_read_queue          [num_read_bloc];
1465            _execute_loop_size_reservation_station [i][j] = _size_reservation_station [num_read_bloc];
1466            _execute_loop_nb_inst_retire           [i][j] = _nb_inst_retire_reservation_station [num_read_bloc];
1467          }
1468      }
1469
1470    ALLOC2(_execute_loop_nb_inst_functionnal_unit                  ,uint32_t,_nb_execute_loop,_execute_loop_nb_functionnal_unit[it1]);
1471    ALLOC4(_execute_loop_timing                                    ,multi_execute_loop::execute_loop::execute_timing_t
1472                                                                            ,_nb_execute_loop,_execute_loop_nb_functionnal_unit[it1],_nb_type,_nb_operation);
1473    ALLOC2(_execute_loop_is_load_store_unit                        ,bool    ,_nb_execute_loop,_nb_execute_unit[it1]);
1474    ALLOC2(_execute_loop_translate_num_execute_unit                ,uint32_t,_nb_execute_loop,_nb_execute_unit[it1]);
1475   
1476//     for (uint32_t i=0; i<_nb_execute_loop; ++i)
1477//       {
1478//         for (uint32_t j=0; j<_nb_execute_unit [i]; ++j)
1479//           {
1480//             _execute_loop_is_load_store_unit         [i][j] = false;
1481//             _execute_loop_translate_num_execute_unit [i][j] = 0;
1482//           }
1483//         for (uint32_t j=0; j<_execute_loop_nb_functionnal_unit[i]; ++j)
1484//           for (uint32_t k=0; k<_nb_type; ++k)
1485//             for (uint32_t l=0; l<_nb_operation; ++l)
1486//               _execute_loop_timing [i][j][k][l]._delay = _execute_loop_timing [i][j][k][l]._latence = 0;
1487//       }
1488
1489    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1490      {
1491        uint32_t num_lsu = 0;
1492        uint32_t num_fu  = 0;
1493        for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
1494          {
1495            uint32_t num_functionnal_unit = _link_functionnal_unit_with_execute_unit [i][j];
1496            uint32_t num_load_store_unit  = _link_load_store_unit_with_execute_unit  [i][j];
1497           
1498            bool is_lsu = (num_load_store_unit != _nb_load_store_unit);
1499           
1500            _execute_loop_is_load_store_unit [i][j] = is_lsu;
1501           
1502            if (is_lsu)
1503              {
1504                // update translation
1505                _execute_loop_translate_num_execute_unit [i][j] = num_lsu;
1506                num_lsu ++;
1507              }
1508            else
1509              {
1510                // update translation
1511                _execute_loop_translate_num_execute_unit [i][j] = num_fu;
1512
1513                // timing information
1514                _execute_loop_nb_inst_functionnal_unit [i][num_fu] = _nb_inst_functionnal_unit [num_functionnal_unit];
1515               
1516                log_printf(TRACE,Core,FUNCTION,_("   * _execute_loop_nb_inst_functionnal_unit [%d][%d] = _nb_inst_functionnal_unit [%d] = %d"),i,num_fu,num_functionnal_unit,_nb_inst_functionnal_unit [num_functionnal_unit]);
1517
1518                for (uint32_t k=0; k<_nb_type; ++k)
1519                  for (uint32_t l=0; l<_nb_operation; ++l)
1520                    {
1521//                       log_printf(TRACE,Core,FUNCTION,_("execute_loop_timing [%d][%d][%d][%d] = timing [%d][%d][%d]"),i,num_fu,k,l,num_functionnal_unit,k,l);
1522                      _execute_loop_timing [i][num_fu][k][l] = _timing [num_functionnal_unit][k][l];
1523                    }
1524               
1525//               // is not a load store unit
1526//               for (uint32_t k=0; k<_nb_operation; ++k)
1527//                 _execute_loop_timing [i][j][TYPE_MEMORY][k]._delay = _execute_loop_timing [i][j][TYPE_MEMORY][k]._latence = 0;
1528
1529                num_fu ++;
1530              }
1531          }
1532      }
1533   
1534    ALLOC2(_execute_loop_size_store_queue                          ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1535    ALLOC2(_execute_loop_size_load_queue                           ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1536    ALLOC2(_execute_loop_size_speculative_access_queue             ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1537    ALLOC2(_execute_loop_nb_port_check                             ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1538    ALLOC2(_execute_loop_speculative_load                          ,multi_execute_loop::execute_loop::Tspeculative_load_t
1539                                                                            ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1540    ALLOC2(_execute_loop_nb_bypass_memory                          ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1541    ALLOC2(_execute_loop_nb_cache_port                             ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1542    ALLOC2(_execute_loop_nb_inst_memory                            ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1543   
1544    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1545      for (uint32_t j=0; j<_execute_loop_nb_load_store_unit[i]; ++j)
1546        {
1547          uint32_t num_load_store_unit = _list_load_store_unit_with_execute_unit [i][j];
1548   
1549          log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_nb_load_store_unit [%d][%d] : %d"),i,j,num_load_store_unit);
1550          log_printf(TRACE,Core,FUNCTION,_("    * nb_bypass_memory : %d"),_nb_bypass_memory[num_load_store_unit]);
1551
1552          _execute_loop_size_store_queue              [i][j] = _size_store_queue              [num_load_store_unit];
1553          _execute_loop_size_load_queue               [i][j] = _size_load_queue               [num_load_store_unit];
1554          _execute_loop_size_speculative_access_queue [i][j] = _size_speculative_access_queue [num_load_store_unit];
1555          _execute_loop_nb_port_check                 [i][j] = _nb_port_check                 [num_load_store_unit];
1556          _execute_loop_speculative_load              [i][j] = _speculative_load              [num_load_store_unit];
1557          _execute_loop_nb_bypass_memory              [i][j] = _nb_bypass_memory              [num_load_store_unit];
1558          _execute_loop_nb_cache_port                 [i][j] = _nb_cache_port                 [num_load_store_unit];
1559          _execute_loop_nb_inst_memory                [i][j] = _nb_inst_memory                [num_load_store_unit];
1560        }
1561
1562    ALLOC2(_execute_loop_size_write_queue                          ,uint32_t,_nb_execute_loop,_nb_write_unit[it1]);
1563    ALLOC2(_execute_loop_size_execute_queue                        ,uint32_t,_nb_execute_loop,_nb_write_unit[it1]);
1564    ALLOC2(_execute_loop_nb_bypass_write                           ,uint32_t,_nb_execute_loop,_nb_write_unit[it1]);
1565    ALLOC2(_execute_loop_write_queue_scheme                        ,multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t,_nb_execute_loop,_nb_write_unit[it1]);
1566   
1567    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1568      for (uint32_t j=0; j<_nb_write_unit[i]; ++j)
1569        {
1570          uint32_t num_write_bloc = _link_write_bloc_with_write_unit [i][j];
1571   
1572          _execute_loop_size_write_queue   [i][j] = _size_write_queue   [num_write_bloc];
1573          _execute_loop_size_execute_queue [i][j] = _size_execute_queue [num_write_bloc];
1574          _execute_loop_nb_bypass_write    [i][j] = _nb_bypass_write    [num_write_bloc];
1575          _execute_loop_write_queue_scheme [i][j] = _write_queue_scheme [num_write_bloc];
1576        }
1577   
1578    ALLOC2(_execute_loop_nb_general_register                       ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
1579    ALLOC2(_execute_loop_nb_special_register                       ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
1580    ALLOC2(_execute_loop_nb_inst_insert_rob                        ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
1581    ALLOC2(_execute_loop_nb_inst_retire_rob                        ,uint32_t,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
1582   
1583    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1584      for (uint32_t j=0; j<_execute_loop_nb_ooo_engine[i]; ++j)
1585        {
1586          uint32_t num_ooo_engine = _list_ooo_engine_with_execute_loop[i][j];
1587   
1588          // sum number of general register
1589          uint32_t gpr_reg = *std::max_element(_ooo_engine_nb_general_register[num_ooo_engine],
1590                                               _ooo_engine_nb_general_register[num_ooo_engine]+_nb_rename_unit[num_ooo_engine]);
1591   
1592          gpr_reg *= _nb_rename_unit[num_ooo_engine]; 
1593   
1594          _execute_loop_nb_general_register [i][j] = gpr_reg;
1595   
1596          // sum number of special register
1597          uint32_t spr_reg = *std::max_element(_ooo_engine_nb_special_register[num_ooo_engine],
1598                                               _ooo_engine_nb_special_register[num_ooo_engine]+_nb_rename_unit[num_ooo_engine]);
1599   
1600          spr_reg *= _nb_rename_unit[num_ooo_engine]; 
1601   
1602          _execute_loop_nb_special_register [i][j] = spr_reg;
1603   
1604   
1605          uint32_t insert = 0;
1606          uint32_t retire = 0;
1607         
1608          for (uint32_t k=0; k<_nb_rename_unit[num_ooo_engine]; ++k)
1609            {
1610              insert = _ooo_engine_nb_inst_insert [num_ooo_engine][k];
1611              retire = _ooo_engine_nb_inst_retire [num_ooo_engine][k];
1612            }
1613         
1614          _execute_loop_nb_inst_insert_rob  [i][j] = insert;
1615          _execute_loop_nb_inst_retire_rob  [i][j] = retire;
1616        }
1617   
1618    ALLOC2(_execute_loop_nb_execute_unit_port                      ,uint32_t,_nb_execute_loop,_nb_execute_unit[it1]);
1619   
1620    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1621      for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
1622        {
1623          uint32_t num_functionnal_unit = _link_functionnal_unit_with_execute_unit [i][j];
1624          uint32_t num_load_store_unit  = _link_load_store_unit_with_execute_unit  [i][j];
1625   
1626          if (num_functionnal_unit != _nb_functionnal_unit)
1627            _execute_loop_nb_execute_unit_port [i][j] = _nb_inst_functionnal_unit [num_functionnal_unit];
1628          else
1629            {
1630              _execute_loop_nb_execute_unit_port [i][j] = _nb_inst_memory [num_load_store_unit];
1631
1632#ifdef DEBUG_TEST
1633              if (num_load_store_unit == _nb_load_store_unit)
1634                throw ERRORMORPHEO(FUNCTION,_("execute_unit is not a functional unit and load store unit."));
1635#endif
1636            }
1637        }
1638   
1639    ALLOC4(_execute_loop_read_unit_to_execution_unit_table_routing ,bool    ,_nb_execute_loop,_nb_read_unit[it1],_nb_execute_unit[it1],_execute_loop_nb_execute_unit_port[it1][it2]);
1640   
1641    log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_read_unit_to_execution_unit_table_routing [execute_loop][read_unit][execute_unit][execute_unit_port]"));
1642    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1643      for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
1644        {
1645          uint32_t num_functionnal_unit = _link_functionnal_unit_with_execute_unit [i][j];
1646          uint32_t num_load_store_unit  = _link_load_store_unit_with_execute_unit  [i][j];
1647         
1648          bool is_lsu = (num_load_store_unit != _nb_load_store_unit);
1649         
1650          for (uint32_t l=0; l<_nb_read_unit[i];++l)
1651            {
1652              uint32_t num_read_bloc = _link_read_bloc_with_read_unit [i][l];
1653              bool link = false;
1654             
1655              if (is_lsu)
1656                link = _link_read_bloc_and_load_store_unit  [num_read_bloc][num_load_store_unit];
1657              else
1658                link = _link_read_bloc_and_functionnal_unit [num_read_bloc][num_functionnal_unit];
1659             
1660              log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d][all (%d)] -> %d"),i,l,j,_execute_loop_nb_execute_unit_port [i][j],link);
1661             
1662              for (uint32_t k=0; k<_execute_loop_nb_execute_unit_port [i][j]; ++k)
1663                _execute_loop_read_unit_to_execution_unit_table_routing [i][l][j][k] = link;
1664            }
1665        }
1666   
1667    ALLOC4(_execute_loop_execution_unit_to_write_unit_table_routing,bool    ,_nb_execute_loop,_nb_execute_unit[it1],_execute_loop_nb_execute_unit_port[it1][it2],_nb_write_unit[it1]);
1668   
1669    log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_execution_unit_to_write_unit_table_routing [execute_loop][execute_unit][execute_unit_port][write_unit]"));
1670
1671    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1672      for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
1673        {
1674          uint32_t num_functionnal_unit = _link_functionnal_unit_with_execute_unit [i][j];
1675          uint32_t num_load_store_unit  = _link_load_store_unit_with_execute_unit  [i][j];
1676         
1677          bool is_lsu = (num_load_store_unit != _nb_load_store_unit);
1678         
1679          for (uint32_t l=0; l<_nb_write_unit[i];++l)
1680            {
1681              uint32_t num_write_bloc = _link_write_bloc_with_write_unit [i][l];
1682              bool link = false;
1683             
1684              if (is_lsu)
1685                link = _link_write_bloc_and_load_store_unit  [num_write_bloc][num_load_store_unit];
1686              else
1687                link = _link_write_bloc_and_functionnal_unit [num_write_bloc][num_functionnal_unit];
1688             
1689              log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][all (%d)][%d] -> %d"),i,j,_execute_loop_nb_execute_unit_port [i][j],l,link);
1690             
1691              for (uint32_t k=0; k<_execute_loop_nb_execute_unit_port [i][j]; ++k)
1692                _execute_loop_execution_unit_to_write_unit_table_routing [i][j][k][l] = link;
1693            }
1694        }
1695   
1696    ALLOC3(_execute_loop_read_unit_to_execution_unit_table_thread  ,bool    ,_nb_execute_loop,_nb_execute_unit[it1],_execute_loop_nb_thread[it1]);
1697    ALLOC3(_execute_loop_execution_unit_to_write_unit_table_thread ,bool    ,_nb_execute_loop,_nb_write_unit[it1],_execute_loop_nb_thread [it1]);
1698   
1699    log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_read_unit_to_execution_unit_table_thread"));
1700    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1701      {
1702        for (uint32_t k=0; k<_execute_loop_nb_thread[i]; ++k)
1703          {
1704            for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
1705              _execute_loop_read_unit_to_execution_unit_table_thread  [i][j][k] = false;
1706            for (uint32_t j=0; j<_nb_write_unit[i]; ++j)
1707              _execute_loop_execution_unit_to_write_unit_table_thread [i][j][k] = false;
1708          }
1709   
1710        for (uint32_t j=0; j<_nb_execute_unit[i]; ++j)
1711          {
1712            uint32_t num_functionnal_unit = _link_functionnal_unit_with_execute_unit [i][j];
1713            uint32_t num_load_store_unit  = _link_load_store_unit_with_execute_unit  [i][j];
1714           
1715            bool is_lsu = (num_load_store_unit != _nb_load_store_unit);
1716       
1717            // Test this execute_unit
1718            for (uint32_t k=0; k<_nb_thread; ++k)
1719              {
1720                // Have a link ?
1721                bool have_link = (is_lsu)?(_link_load_store_unit_with_thread [k] == num_load_store_unit):(_link_thread_and_functionnal_unit [k][num_functionnal_unit]);
1722               
1723                if (have_link)
1724                    {
1725                      uint32_t num_thread = execute_loop_get_num_thread (i,k);
1726
1727#ifdef DEBUG_TEST
1728                      if (num_thread == static_cast<Tcontext_t>(-1))
1729                        throw ERRORMORPHEO(FUNCTION,toString(_("execute_loop [%d] : thread %d is invalid."),i,k));
1730#endif
1731
1732                      _execute_loop_read_unit_to_execution_unit_table_thread [i][j][num_thread] = true;
1733                      log_printf(TRACE,Core,FUNCTION,_("   [%d][%d][%d] -> Ok"),i,j,num_thread);
1734             
1735                    }
1736              }
1737   
1738            for (uint32_t k=0; k<_nb_write_unit[i]; ++k)
1739              {
1740                uint32_t num_write_bloc = _link_write_bloc_with_write_unit[i][k];
1741                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]);
1742                 
1743                if (have_link)
1744                  for (uint32_t l=0; l<_execute_loop_nb_thread [i]; ++l)
1745                    _execute_loop_execution_unit_to_write_unit_table_thread [i][k][l] |= _execute_loop_read_unit_to_execution_unit_table_thread  [i][j][l];
1746              }
1747          }
1748      }
1749   
1750    ALLOC2(_execute_loop_num_thread_valid                          ,bool    ,_nb_execute_loop,_execute_loop_nb_thread[it1]);
1751
1752    log_printf(TRACE,Core,FUNCTION,_("  * execute_loop_num_thread_valid"));
1753
1754    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1755      {
1756        for (uint32_t j=0; j<_execute_loop_nb_thread[i]; ++j)
1757          _execute_loop_num_thread_valid [i][j] = false;
1758
1759        for (uint32_t j=0; j<_nb_thread; ++j)
1760          {
1761            uint32_t num_thread = execute_loop_get_num_thread (i,j);
1762         
1763            if (num_thread != static_cast<Tcontext_t>(-1))
1764              {
1765                log_printf(TRACE,Core,FUNCTION,_("   [%d][%d] -> valid"),i,num_thread);
1766
1767                _execute_loop_num_thread_valid [i][num_thread] = true;
1768              }
1769          }
1770      }
1771
1772
1773    ALLOC2(_icache_access_size_packet_id,uint32_t,_nb_front_end,_nb_context[it1]);
1774    ALLOC2(_icache_access_table_routing ,uint32_t,_nb_front_end,_nb_context[it1]);
1775   
1776    for (uint32_t i=0; i<_nb_front_end; ++i)
1777      for (uint32_t j=0; j<_nb_context[i]; ++j)
1778        {
1779          uint32_t num_thread = _link_thread_with_context [i][j];
1780         
1781          _icache_access_size_packet_id [i][j] = log2(_front_end_size_ifetch_queue[i][j]);
1782          _icache_access_table_routing  [i][j] = _link_icache_port_with_thread [num_thread];
1783        }
1784   
1785    ALLOC1(_icache_nb_instruction     ,uint32_t,_nb_icache_port);
1786   
1787    for (uint32_t i=0; i<_nb_icache_port; ++i)
1788      _icache_nb_instruction [i] = 0;
1789    for (uint32_t i=0; i<_nb_front_end; i++)
1790      for (uint32_t j=0; j<_nb_context[i]; j++)
1791        {
1792          uint32_t port = _icache_access_table_routing [i][j];
1793         
1794          // Take the greater
1795          if (_icache_nb_instruction[port] < _front_end_nb_inst_fetch [i][j])
1796            _icache_nb_instruction[port] = _front_end_nb_inst_fetch [i][j];
1797        }
1798 
1799    ALLOC2(_dcache_access_size_thread_id,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1800    ALLOC2(_dcache_access_size_packet_id,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
1801    ALLOC3(_dcache_access_table_routing ,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],_execute_loop_nb_cache_port[it1][it2]);
1802   
1803   
1804    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1805      for (uint32_t j=0; j<_execute_loop_nb_load_store_unit[i]; ++j)
1806        {
1807          uint32_t num_load_store_unit = _list_load_store_unit_with_execute_unit [i][j];
1808   
1809          for (uint32_t k=0; k<_execute_loop_nb_cache_port [i][j]; ++k)
1810            _dcache_access_table_routing [i][j][k] = _link_dcache_port_with_load_store_unit [num_load_store_unit][k];
1811   
1812          _dcache_access_size_thread_id [i][j] =  (log2(_execute_loop_nb_context    [i]) +
1813                                                   log2(_execute_loop_nb_front_end  [i]) +
1814                                                   log2(_execute_loop_nb_ooo_engine [i]));
1815   
1816          // max size +1 (+1 to add a bit to select the queue)
1817          _dcache_access_size_packet_id [i][j] = log2(std::max(_size_store_queue[num_load_store_unit],
1818                                                               _size_load_queue [num_load_store_unit]))+1;
1819        }
1820
1821    ALLOC1(_dcache_access_nb_context                         ,uint32_t,_nb_execute_loop);
1822
1823    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1824      _dcache_access_nb_context [i] = 1<<max<uint32_t>(_dcache_access_size_thread_id [i],_execute_loop_nb_load_store_unit[i]);
1825
1826    ALLOC3(_dcache_access_translate_load_store_unit_to_thread,uint32_t,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],_dcache_access_nb_context[it1]);
1827
1828    // parameters depends
1829    _size_context_id                       = log2(max<uint32_t>(_nb_context,_nb_front_end));
1830    _size_front_end_id                     = log2(_nb_front_end);
1831
1832    for (uint32_t i=0; i<_nb_execute_loop; ++i)
1833      for (uint32_t j=0; j<_execute_loop_nb_load_store_unit[i]; ++j)
1834        {
1835          uint32_t num_load_store_unit = _list_load_store_unit_with_execute_unit [i][j];
1836         
1837          {
1838            uint32_t num_thread;
1839            for (num_thread = 0; num_thread<_nb_thread; ++num_thread)
1840              if (_link_load_store_unit_with_thread [num_thread] == num_load_store_unit)
1841                break;
1842#ifdef DEBUG_TEST
1843            if (num_thread == _nb_thread)
1844              throw ERRORMORPHEO(FUNCTION,toString(_("Load_store_unit [%d] is not link with a thread.\n"),num_load_store_unit));
1845#endif
1846          }
1847
1848          // init with an invalid thread_id
1849          for (uint32_t k=0; k<_dcache_access_nb_context [i]; ++k)
1850            _dcache_access_translate_load_store_unit_to_thread [i][j][k] = _nb_thread;
1851         
1852          // cf Load_store_unit : create thread_id
1853          // dcache_req_context_id = ((ooo_engine_id<<(_param->_size_context_id + _param->_size_front_end_id )) |
1854          //                          (front_end_id <<(_param->_size_context_id)) |
1855          //                          (context_id));
1856         
1857          for (std::vector<uint32_t>::iterator it=_list_ooo_engine_with_execute_loop[i].begin();
1858               it!=_list_ooo_engine_with_execute_loop[i].end();
1859               ++it)
1860            {
1861              uint32_t num_ooo_engine = *it;
1862              for (uint32_t x=0; x<_ooo_engine_nb_front_end[num_ooo_engine]; ++x)
1863                {
1864                  uint32_t num_front_end = _translate_ooo_engine_num_front_end [num_ooo_engine][x];
1865                 
1866                  for (uint32_t num_context = 0; num_context < _nb_context[num_front_end]; ++num_context)
1867                    {
1868                      uint32_t num_thread = _link_thread_with_context [num_front_end][num_context];
1869                     
1870                      if (_link_load_store_unit_with_thread [num_thread] == num_load_store_unit)
1871                        {
1872                          uint32_t index = ((num_ooo_engine<<(_size_context_id + _size_front_end_id )) |
1873                                            (num_front_end <<(_size_context_id)) |
1874                                            (num_context));
1875                         
1876                          _dcache_access_translate_load_store_unit_to_thread [i][j][index] = num_thread;
1877                        }
1878                    }
1879                }
1880            }
1881        }
1882
1883    ALLOC1(_issue_queue_in_order,bool,_nb_ooo_engine);
1884    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1885      _issue_queue_in_order [i] = (_issue_queue_scheme [i] == core::multi_ooo_engine::ooo_engine::issue_queue::ISSUE_QUEUE_SCHEME_IN_ORDER);
1886
1887    // parameters depends
1888    _size_ooo_engine_id                    = log2(_nb_ooo_engine);
1889    _size_instruction_address              = size_general_data-2;
1890    _size_data_address                     = size_general_data;
1891    _size_nb_inst_decod                    = log2(max<uint32_t>(_size_decod_queue,_nb_decod_bloc    ))+1;
1892    _size_nb_inst_commit                   = log2(max<uint32_t>(_size_re_order_buffer,_nb_ooo_engine))+1;
1893    _size_depth                            = log2(max<uint32_t>(_upt_size_queue,_nb_thread));
1894    _size_ifetch_queue_ptr                 = log2(max<uint32_t>(_size_ifetch_queue,_nb_thread));
1895    _size_inst_ifetch_ptr                  = log2(max<uint32_t>(_nb_inst_fetch,_nb_thread));
1896    _size_rob_ptr                          = _size_nb_inst_commit; // nb_rob_bank must be a multiple of size_rob
1897    _size_load_queue_ptr                   = log2(max<uint32_t>(_size_load_queue ,_nb_load_store_unit));
1898    _size_store_queue_ptr                  = log2(max<uint32_t>(_size_store_queue,_nb_load_store_unit));
1899    _size_general_data                     = size_general_data;
1900    _size_special_data                     = size_special_data;
1901    _size_general_register                 = log2(max<uint32_t>(_nb_general_register,_nb_rename_bloc));
1902    _size_special_register                 = log2(max<uint32_t>(_nb_special_register,_nb_rename_bloc));
1903   
1904    _have_port_context_id                  = _size_context_id       > 0;
1905    _have_port_front_end_id                = _size_front_end_id     > 0;
1906    _have_port_ooo_engine_id               = _size_ooo_engine_id    > 0;
1907    _have_port_depth                       = _size_depth            > 0;
1908    _have_port_ifetch_queue_ptr            = _size_ifetch_queue_ptr > 0;
1909    _have_port_inst_ifetch_ptr             = _size_inst_ifetch_ptr  > 0;
1910    _have_port_rob_ptr                     = _size_rob_ptr          > 0;
1911    _have_port_load_queue_ptr              = _size_load_queue_ptr   > 0;
1912
1913    // interface parameters
1914    _size_icache_thread_id                 = log2(_nb_thread);
1915//  _size_icache_thread_id                 = log2(_nb_front_end) + log2(max<uint32_t>(_nb_context,_nb_front_end));
1916    _size_icache_packet_id                 = _size_ifetch_queue_ptr; 
1917//  _size_icache_packet_id                 = max<uint32_t>(_icache_access_size_packet_id,_nb_front_end, _nb_context);
1918    _size_icache_address                   = _size_instruction_address;
1919    _have_port_icache_thread_id            = _size_icache_thread_id > 0;
1920    _have_port_icache_packet_id            = _size_icache_packet_id > 0;
1921    _size_dcache_thread_id                 = _size_icache_thread_id;
1922//  _size_dcache_thread_id                 = (log2(_nb_execute_loop) +
1923//                                            log2(max<uint32_t>(_execute_loop_nb_load_store_unit, _nb_execute_loop)) +
1924//                                            log2(max<uint32_t>(_execute_loop_nb_cache_port, _nb_execute_loop, _execute_loop_nb_load_store_unit)) +
1925//                                            max<uint32_t>(_dcache_access_size_packet_id    , _nb_execute_loop, _execute_loop_nb_load_store_unit));
1926    _size_dcache_packet_id                 = max<uint32_t>(_dcache_access_size_packet_id, _nb_execute_loop, _execute_loop_nb_load_store_unit);
1927    _size_dcache_address                   = _size_data_address;
1928    _size_dcache_data                      = _size_general_data;
1929                                           
1930    _have_port_dcache_thread_id            = _size_dcache_thread_id > 0;
1931    _have_port_dcache_packet_id            = _size_dcache_packet_id > 0; // always 1
1932
1933
1934    _param_front_end = new core::multi_front_end::front_end::Parameters * [_nb_front_end];
1935
1936    for (uint32_t i=0; i<_nb_front_end; ++i)
1937      _param_front_end [i]= new core::multi_front_end::front_end::Parameters
1938        (
1939        _nb_context                             [i],
1940        _nb_decod_unit                          [i],
1941        _size_general_data                         ,
1942        _get_custom_information                    ,
1943        _front_end_size_ifetch_queue            [i],
1944        _front_end_nb_inst_fetch                [i],
1945        _front_end_instruction_implemeted       [i],
1946        _front_end_link_decod_unit_with_context [i],
1947        _front_end_size_decod_queue             [i],
1948        _front_end_decod_queue_scheme           [i],
1949        _front_end_nb_inst_decod                [i],
1950        _front_end_nb_context_select            [i],
1951        _front_end_context_select_priority      [i],
1952        _front_end_context_select_load_balancing[i],
1953        _nb_inst_branch_predict                 [i],
1954        _nb_inst_branch_decod                   [i],
1955        _nb_inst_branch_update                  [i],
1956        _front_end_nb_inst_branch_complete      [i],
1957        _btb_size_queue                         [i],
1958        _btb_associativity                      [i],
1959        _btb_size_counter                       [i],
1960        _btb_victim_scheme                      [i],
1961        _dir_predictor_scheme                   [i],
1962        _dir_have_bht                           [i],
1963        _dir_bht_size_shifter                   [i],
1964        _dir_bht_nb_shifter                     [i],
1965        _dir_have_pht                           [i],
1966        _dir_pht_size_counter                   [i],
1967        _dir_pht_nb_counter                     [i],
1968        _dir_pht_size_address_share             [i],
1969        _front_end_ras_size_queue               [i],
1970        _front_end_upt_size_queue               [i],
1971        _front_end_ufpt_size_queue              [i],
1972        _size_nb_inst_commit                       ,
1973        _nb_thread                                 ,
1974        _link_thread_with_context               [i]
1975         );
1976
1977    ALLOC1(_nb_inst_issue_queue,uint32_t,_nb_ooo_engine);
1978
1979    _param_ooo_engine = new core::multi_ooo_engine::ooo_engine::Parameters * [_nb_ooo_engine];
1980
1981    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
1982      {
1983    _param_ooo_engine [i] = new core::multi_ooo_engine::ooo_engine::Parameters
1984      (
1985       _ooo_engine_nb_front_end                      [i],
1986       _ooo_engine_nb_context                        [i],
1987       _nb_rename_unit                               [i],
1988       _ooo_engine_nb_execute_loop                   [i],
1989       _ooo_engine_nb_inst_decod                     [i],
1990       _ooo_engine_nb_inst_insert                    [i],
1991       _ooo_engine_nb_inst_retire                    [i],
1992//        _nb_inst_issue                                [i],
1993       _ooo_engine_nb_inst_execute                   [i],
1994       _nb_inst_reexecute                            [i],
1995       _nb_inst_commit                               [i],
1996       _nb_inst_branch_complete                      [i],
1997       _ooo_engine_nb_branch_speculated              [i],
1998       _size_nb_inst_decod                              ,
1999       _nb_rename_unit_select                        [i],
2000       _nb_execute_loop_select                       [i],
2001       _size_general_data                               ,
2002       _size_special_data                               ,
2003       _ooo_engine_link_rename_unit_with_front_end   [i],
2004       _size_re_order_buffer                         [i],
2005       _nb_re_order_buffer_bank                      [i],
2006       _commit_priority                              [i],
2007       _commit_load_balancing                        [i],
2008       _size_issue_queue                             [i],
2009       _issue_queue_scheme                           [i],
2010       _nb_issue_queue_bank                          [i],
2011       _issue_priority                               [i],
2012       _issue_load_balancing                         [i],
2013//        _ooo_engine_table_routing                     [i],
2014//        _ooo_engine_table_issue_type                  [i],
2015       _size_reexecute_queue                         [i],
2016       _reexecute_priority                           [i],
2017       _reexecute_load_balancing                     [i],
2018       _ooo_engine_rename_select_priority            [i],
2019       _ooo_engine_rename_select_load_balancing      [i],
2020       _ooo_engine_rename_select_nb_front_end_select [i],
2021       _ooo_engine_nb_general_register               [i],
2022       _ooo_engine_nb_special_register               [i],
2023       _ooo_engine_nb_reg_free                       [i],
2024       _ooo_engine_nb_rename_unit_bank               [i],
2025//     _ooo_engine_size_read_counter                 [i],
2026       _ooo_engine_nb_load_store_unit                [i],
2027       _ooo_engine_size_store_queue                  [i],
2028       _ooo_engine_size_load_queue                   [i],
2029       _ooo_engine_nb_inst_memory                    [i],
2030       _ooo_engine_link_load_store_unit_with_context [i],
2031       _ooo_engine_implement_group                   [i],
2032       _nb_thread                                       ,
2033       _ooo_engine_translate_num_context_to_num_thread[i]
2034       );
2035    _nb_inst_issue_queue [i] = _param_ooo_engine [i]->_nb_inst_issue;
2036      }
2037
2038    _param_execute_loop = new core::multi_execute_loop::execute_loop::Parameters * [_nb_execute_loop];
2039
2040    for (uint32_t i=0; i<_nb_execute_loop; ++i)
2041      _param_execute_loop [i] = new core::multi_execute_loop::execute_loop::Parameters
2042        (
2043         _nb_read_unit                                            [i],
2044         _execute_loop_nb_functionnal_unit                        [i],
2045         _execute_loop_nb_load_store_unit                         [i],
2046         _nb_write_unit                                           [i],
2047
2048         _execute_loop_nb_context                                 [i],
2049         _execute_loop_nb_front_end                               [i],
2050         _execute_loop_nb_ooo_engine                              [i],
2051         _execute_loop_nb_packet                                  [i],
2052         _size_general_data                                          ,
2053         _size_special_data                                          ,
2054
2055         _execute_loop_size_read_queue                            [i],
2056         _execute_loop_size_reservation_station                   [i],
2057         _execute_loop_nb_inst_retire                             [i],
2058
2059         _execute_loop_nb_inst_functionnal_unit                   [i],
2060         _execute_loop_timing                                     [i],
2061         _get_custom_information                                     ,
2062
2063         _execute_loop_size_store_queue                           [i],
2064         _execute_loop_size_load_queue                            [i],
2065         _execute_loop_size_speculative_access_queue              [i],
2066         _execute_loop_nb_port_check                              [i],
2067         _execute_loop_speculative_load                           [i],
2068         _execute_loop_nb_bypass_memory                           [i],
2069         _execute_loop_nb_cache_port                              [i],
2070         _execute_loop_nb_inst_memory                             [i],
2071
2072         _execute_loop_size_write_queue                           [i],
2073         _execute_loop_size_execute_queue                         [i],
2074         _execute_loop_nb_bypass_write                            [i],
2075         _execute_loop_write_queue_scheme                         [i],
2076
2077         _nb_gpr_bank                                             [i],
2078         _nb_gpr_port_read_by_bank                                [i],
2079         _nb_gpr_port_write_by_bank                               [i],
2080         _nb_spr_bank                                             [i],
2081         _nb_spr_port_read_by_bank                                [i],
2082         _nb_spr_port_write_by_bank                               [i],
2083         _execute_loop_nb_general_register                        [i],
2084         _execute_loop_nb_special_register                        [i],
2085         _execute_loop_nb_inst_insert_rob                         [i],
2086         _execute_loop_nb_inst_retire_rob                         [i],
2087
2088         _execution_unit_to_write_unit_priority                   [i],
2089         _execute_loop_execution_unit_to_write_unit_table_routing [i],
2090         _execute_loop_execution_unit_to_write_unit_table_thread  [i],
2091
2092         _read_unit_to_execution_unit_priority                    [i],
2093         _execute_loop_read_unit_to_execution_unit_table_routing  [i],
2094         _execute_loop_read_unit_to_execution_unit_table_thread   [i],
2095
2096         _execute_loop_is_load_store_unit                         [i],
2097         _execute_loop_translate_num_execute_unit                 [i],
2098
2099         _execute_loop_num_thread_valid                           [i]
2100         );
2101
2102    _param_icache_access = new core::icache_access::Parameters
2103      (
2104       _nb_thread                   ,
2105       _nb_front_end                ,
2106       _nb_context                  ,
2107       _nb_icache_port              ,
2108       _size_icache_address         ,
2109       _size_icache_thread_id       ,
2110       _size_icache_packet_id       ,
2111       _front_end_nb_inst_fetch     ,
2112       _icache_access_size_packet_id,
2113       _icache_access_table_routing ,
2114       _icache_port_priority        ,
2115       _icache_port_load_balancing  ,
2116       _link_thread_with_context
2117       );
2118
2119    _param_dcache_access = new core::dcache_access::Parameters
2120      (
2121       _nb_thread                            ,
2122       _nb_execute_loop                      ,
2123       _execute_loop_nb_load_store_unit      ,
2124       _dcache_access_nb_context             ,
2125       _execute_loop_nb_cache_port           ,
2126       _nb_dcache_port                       ,
2127       _size_dcache_address                  ,
2128       _size_dcache_data                     ,
2129       _size_dcache_thread_id                ,
2130       _size_dcache_packet_id                ,
2131       _dcache_access_size_thread_id         ,
2132       _dcache_access_size_packet_id         ,
2133       _dcache_access_table_routing          ,
2134       _dcache_port_priority                 ,
2135       _dcache_port_load_balancing           ,
2136       _dcache_access_translate_load_store_unit_to_thread
2137       );
2138
2139    _param_glue          = new core::core_glue::Parameters
2140      (
2141       _nb_front_end                         ,
2142       _nb_context                           ,//[nb_front_end]
2143       _nb_ooo_engine                        ,
2144       _nb_execute_loop                      ,
2145       _ooo_engine_nb_front_end              ,//[nb_ooo_engine]
2146       _ooo_engine_nb_execute_loop           ,//[nb_ooo_engine]
2147       _execute_loop_nb_ooo_engine           ,//[nb_execute_loop]
2148       _front_end_sum_inst_decod             ,//[nb_front_end] -> [sum_inst_decod]
2149       _front_end_nb_inst_branch_complete    ,//[nb_front_end]
2150       _nb_inst_branch_complete              ,//[nb_ooo_engine]
2151       _ooo_engine_nb_inst_insert_rob        ,//[nb_ooo_engine]
2152       _nb_inst_reexecute                    ,//[nb_ooo_engine]
2153       _nb_inst_issue_queue                  ,//[nb_ooo_engine]
2154       _nb_inst_issue_slot                   ,//[nb_ooo_engine]
2155       _ooo_engine_nb_inst_execute           ,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
2156       _issue_queue_in_order                 ,//[nb_ooo_engine]
2157       _nb_read_unit                         ,//[nb_execute_loop]
2158       _nb_write_unit                        ,//[nb_execute_loop]
2159       _size_depth                           ,
2160       _size_rob_ptr                         ,
2161       _size_load_queue_ptr                  ,
2162       _size_store_queue_ptr                 ,
2163       _size_general_data                    ,
2164       _size_special_data                    ,
2165       _size_general_register                ,
2166       _size_special_register                ,
2167       _dispatch_priority                    ,
2168       _dispatch_load_balancing              ,
2169       _network_table_dispatch               ,//[nb_ooo_engine][nb_inst_issue_slot][nb_execute_loop][nb_read_unit]
2170       _network_table_issue_type             ,//                                   [nb_execute_loop][nb_read_unit][nb_type]
2171       _translate_ooo_engine_num_front_end   ,//[nb_ooo_engine][ooo_engine_nb_front_end]
2172       _translate_ooo_engine_num_execute_loop,//[nb_ooo_engine][ooo_engine_nb_execute_loop]
2173       _translate_execute_loop_num_ooo_engine //[nb_execute_loop][execute_loop_nb_ooo_engine]
2174       );
2175   
2176    copy();
2177
2178    log_end(Core,FUNCTION);
2179  };
2180 
2181// #undef  FUNCTION
2182// #define FUNCTION "Core::Parameters (copy)"
2183//   Parameters::Parameters (Parameters & param)
2184//   {
2185//     log_begin(Core,FUNCTION);
2186//     test();
2187//     log_end(Core,FUNCTION);
2188//   };
2189
2190#undef  FUNCTION
2191#define FUNCTION "Core::~Parameters"
2192  Parameters::~Parameters (void) 
2193  {
2194    log_begin(Core,FUNCTION);
2195
2196    for (uint32_t i=0; i<_nb_front_end; ++i)
2197    delete    _param_front_end [i];
2198    delete [] _param_front_end;
2199    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
2200    delete    _param_ooo_engine [i];
2201    delete [] _param_ooo_engine;
2202    for (uint32_t i=0; i<_nb_execute_loop; ++i)
2203    delete    _param_execute_loop [i];
2204    delete [] _param_execute_loop;
2205    delete    _param_icache_access;
2206    delete    _param_dcache_access;
2207    delete    _param_glue;
2208
2209    DELETE1(_nb_inst_issue_queue                                    ,_nb_ooo_engine);
2210    DELETE1(_issue_queue_in_order                                   ,_nb_ooo_engine);
2211    DELETE3(_dcache_access_translate_load_store_unit_to_thread      ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],_dcache_access_nb_context[it1]);
2212    DELETE1(_dcache_access_nb_context                               ,_nb_execute_loop);
2213    DELETE3(_dcache_access_table_routing                            ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1],_execute_loop_nb_cache_port[it1][it2]);
2214    DELETE2(_dcache_access_size_packet_id                           ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2215    DELETE2(_dcache_access_size_thread_id                           ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2216    DELETE1(_icache_nb_instruction                                  ,_nb_icache_port);
2217    DELETE2(_icache_access_table_routing                            ,_nb_front_end,_nb_context[it1]);
2218    DELETE2(_icache_access_size_packet_id                           ,_nb_front_end,_nb_context[it1]);
2219    DELETE2(_execute_loop_num_thread_valid                          ,_nb_execute_loop,_execute_loop_nb_thread[it1]);
2220    DELETE3(_execute_loop_execution_unit_to_write_unit_table_thread ,_nb_execute_loop,_nb_write_unit[it1],_execute_loop_nb_thread [it1]);
2221    DELETE3(_execute_loop_read_unit_to_execution_unit_table_thread  ,_nb_execute_loop,_nb_execute_unit[it1],_execute_loop_nb_thread[it1]);
2222    DELETE4(_execute_loop_execution_unit_to_write_unit_table_routing,_nb_execute_loop,_nb_execute_unit[it1],_execute_loop_nb_execute_unit_port[it1][it2],_nb_write_unit[it1]);
2223    DELETE4(_execute_loop_read_unit_to_execution_unit_table_routing ,_nb_execute_loop,_nb_read_unit[it1],_nb_execute_unit[it1],_execute_loop_nb_execute_unit_port[it1][it2]);
2224    DELETE2(_execute_loop_nb_execute_unit_port                      ,_nb_execute_loop,_nb_execute_unit[it1]);
2225    DELETE2(_execute_loop_nb_inst_retire_rob                        ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
2226    DELETE2(_execute_loop_nb_inst_insert_rob                        ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
2227    DELETE2(_execute_loop_nb_special_register                       ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
2228    DELETE2(_execute_loop_nb_general_register                       ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
2229    DELETE2(_execute_loop_write_queue_scheme                        ,_nb_execute_loop,_nb_write_unit[it1]);
2230    DELETE2(_execute_loop_nb_bypass_write                           ,_nb_execute_loop,_nb_write_unit[it1]);
2231    DELETE2(_execute_loop_size_execute_queue                        ,_nb_execute_loop,_nb_write_unit[it1]);
2232    DELETE2(_execute_loop_size_write_queue                          ,_nb_execute_loop,_nb_write_unit[it1]);
2233    DELETE2(_execute_loop_nb_inst_memory                            ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2234    DELETE2(_execute_loop_nb_cache_port                             ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2235    DELETE2(_execute_loop_nb_bypass_memory                          ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2236    DELETE2(_execute_loop_speculative_load                          ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2237    DELETE2(_execute_loop_nb_port_check                             ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2238    DELETE2(_execute_loop_size_speculative_access_queue             ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2239    DELETE2(_execute_loop_size_load_queue                           ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2240    DELETE2(_execute_loop_size_store_queue                          ,_nb_execute_loop,_execute_loop_nb_load_store_unit[it1]);
2241    DELETE2(_execute_loop_translate_num_execute_unit                ,_nb_execute_loop,_nb_execute_unit[it1]);
2242    DELETE2(_execute_loop_is_load_store_unit                        ,_nb_execute_loop,_nb_execute_unit[it1]);
2243    DELETE4(_execute_loop_timing                                    ,_nb_execute_loop,_execute_loop_nb_functionnal_unit[it1],_nb_type,_nb_operation);
2244    DELETE2(_execute_loop_nb_inst_functionnal_unit                  ,_nb_execute_loop,_execute_loop_nb_functionnal_unit[it1]);
2245    DELETE2(_execute_loop_nb_inst_retire                            ,_nb_execute_loop,_nb_read_unit[it1]);
2246    DELETE2(_execute_loop_size_reservation_station                  ,_nb_execute_loop,_nb_read_unit[it1]);
2247    DELETE2(_execute_loop_size_read_queue                           ,_nb_execute_loop,_nb_read_unit[it1]);
2248    DELETE2(_translate_execute_loop_num_ooo_engine                  ,_nb_execute_loop,_execute_loop_nb_ooo_engine[it1]);
2249    DELETE1(_execute_loop_nb_thread                                 ,_nb_execute_loop);
2250    DELETE1(_execute_loop_nb_packet                                 ,_nb_execute_loop);
2251    DELETE1(_execute_loop_nb_ooo_engine                             ,_nb_execute_loop);
2252    DELETE1(_execute_loop_nb_context                                ,_nb_execute_loop);
2253    DELETE1(_execute_loop_nb_front_end                              ,_nb_execute_loop);
2254    DELETE1(_list_front_end_with_execute_loop                       ,_nb_execute_loop);
2255    DELETE1(_list_ooo_engine_with_execute_loop                      ,_nb_execute_loop);
2256    DELETE1(_execute_loop_nb_load_store_unit                        ,_nb_execute_loop);
2257    DELETE1(_execute_loop_nb_functionnal_unit                       ,_nb_execute_loop);
2258    DELETE4(_ooo_engine_implement_group                             ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2],NB_GROUP);
2259    DELETE3(_ooo_engine_link_load_store_unit_with_context           ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2]);
2260    DELETE3(_ooo_engine_nb_inst_memory                              ,_nb_ooo_engine,_nb_rename_unit[it1],_ooo_engine_nb_load_store_unit[it1][it2]);
2261    DELETE3(_ooo_engine_size_load_queue                             ,_nb_ooo_engine,_nb_rename_unit[it1],_ooo_engine_nb_load_store_unit[it1][it2]);
2262    DELETE3(_ooo_engine_size_store_queue                            ,_nb_ooo_engine,_nb_rename_unit[it1],_ooo_engine_nb_load_store_unit[it1][it2]);
2263    DELETE2(_ooo_engine_nb_load_store_unit                          ,_nb_ooo_engine,_nb_rename_unit[it1]);
2264    DELETE2(_list_load_store_unit_with_rename_unit                  ,_nb_ooo_engine,_nb_rename_unit[it1]);
2265    DELETE2(_list_functionnal_unit_with_rename_unit                 ,_nb_ooo_engine,_nb_rename_unit[it1]);
2266//  DELETE3(_ooo_engine_table_issue_type                            ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_type);
2267//  DELETE3(_ooo_engine_table_routing                               ,_nb_ooo_engine,_nb_rename_unit[it1],_nb_inst_issue_slot[it1]);
2268    DELETE3(_network_table_issue_type                                                                       ,_nb_execute_loop,_nb_read_unit[it1],_nb_type);
2269    DELETE4(_network_table_dispatch                                 ,_nb_ooo_engine,_nb_inst_issue_slot[it1],_nb_execute_loop,_nb_read_unit[it3]);
2270//  DELETE2(_ooo_engine_size_read_counter                           ,_nb_ooo_engine,_nb_rename_unit[it1]);
2271    DELETE2(_ooo_engine_nb_rename_unit_bank                         ,_nb_ooo_engine,_nb_rename_unit[it1]);
2272    DELETE2(_ooo_engine_nb_reg_free                                 ,_nb_ooo_engine,_nb_rename_unit[it1]);
2273    DELETE2(_ooo_engine_nb_special_register                         ,_nb_ooo_engine,_nb_rename_unit[it1]);
2274    DELETE2(_ooo_engine_nb_general_register                         ,_nb_ooo_engine,_nb_rename_unit[it1]);
2275    DELETE2(_ooo_engine_rename_select_nb_front_end_select           ,_nb_ooo_engine,_nb_rename_unit[it1]);
2276    DELETE2(_ooo_engine_rename_select_load_balancing                ,_nb_ooo_engine,_nb_rename_unit[it1]);
2277    DELETE2(_ooo_engine_rename_select_priority                      ,_nb_ooo_engine,_nb_rename_unit[it1]);
2278    DELETE2(_ooo_engine_nb_inst_retire                              ,_nb_ooo_engine,_nb_rename_unit[it1]);
2279    DELETE1(_ooo_engine_nb_inst_insert_rob                          ,_nb_ooo_engine);
2280    DELETE2(_ooo_engine_nb_inst_insert                              ,_nb_ooo_engine,_nb_rename_unit[it1]);
2281    DELETE2(_ooo_engine_link_rename_unit_with_front_end             ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
2282    DELETE3(_ooo_engine_nb_branch_speculated                        ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2]);
2283    DELETE2(_ooo_engine_nb_inst_execute                             ,_nb_ooo_engine,_ooo_engine_nb_execute_loop[it1]);
2284    DELETE3(_ooo_engine_translate_num_context_to_num_thread         ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1],_ooo_engine_nb_context[it1][it2]);
2285    DELETE2(_ooo_engine_nb_inst_decod                               ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
2286    DELETE2(_ooo_engine_nb_context                                  ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
2287    DELETE2(_translate_ooo_engine_num_execute_loop                  ,_nb_ooo_engine,_ooo_engine_nb_execute_loop[it1]);
2288    DELETE1(_ooo_engine_nb_execute_loop                             ,_nb_ooo_engine);
2289    DELETE2(_translate_ooo_engine_num_front_end                     ,_nb_ooo_engine,_ooo_engine_nb_front_end[it1]);
2290    DELETE1(_ooo_engine_nb_front_end                                ,_nb_ooo_engine);
2291    DELETE2(_front_end_context_select_load_balancing                ,_nb_front_end,_nb_decod_unit[it1]);
2292    DELETE2(_front_end_context_select_priority                      ,_nb_front_end,_nb_decod_unit[it1]);
2293    DELETE2(_front_end_nb_context_select                            ,_nb_front_end,_nb_decod_unit[it1]);
2294    DELETE1(_front_end_sum_inst_decod                               ,_nb_front_end);
2295    DELETE2(_front_end_nb_inst_decod                                ,_nb_front_end,_nb_decod_unit[it1]);
2296    DELETE2(_front_end_decod_queue_scheme                           ,_nb_front_end,_nb_decod_unit[it1]);
2297    DELETE2(_front_end_size_decod_queue                             ,_nb_front_end,_nb_decod_unit[it1]);
2298    DELETE1(_front_end_nb_inst_branch_complete                      ,_nb_front_end);
2299    DELETE3(_front_end_instruction_implemeted                       ,_nb_front_end,_nb_context[it1],NB_INSTRUCTION);
2300    DELETE2(_front_end_ufpt_size_queue                              ,_nb_front_end,_nb_context[it1]);
2301    DELETE2(_front_end_upt_size_queue                               ,_nb_front_end,_nb_context[it1]);
2302    DELETE2(_front_end_ras_size_queue                               ,_nb_front_end,_nb_context[it1]);
2303    DELETE2(_front_end_link_decod_unit_with_context                 ,_nb_front_end,_nb_context[it1]);
2304    DELETE2(_front_end_nb_inst_fetch                                ,_nb_front_end,_nb_context[it1]);
2305    DELETE2(_front_end_size_ifetch_queue                            ,_nb_front_end,_nb_context[it1]);
2306    DELETE1(_list_load_store_unit_with_execute_unit                 ,_nb_execute_loop);
2307    DELETE1(_list_functionnal_unit_with_execute_unit                ,_nb_execute_loop);
2308    DELETE2(_link_load_store_unit_with_execute_unit                 ,_nb_execute_loop,_nb_execute_unit[it1]);
2309    DELETE2(_link_functionnal_unit_with_execute_unit                ,_nb_execute_loop,_nb_execute_unit[it1]);
2310    DELETE2(_link_write_bloc_with_write_unit                        ,_nb_execute_loop,_nb_write_unit[it1]);
2311    DELETE2(_link_read_bloc_with_read_unit                          ,_nb_execute_loop,_nb_read_unit[it1]);
2312    DELETE2(_link_rename_bloc_with_rename_unit                      ,_nb_ooo_engine,_nb_rename_unit[it1]);
2313    DELETE2(_link_decod_bloc_with_decod_unit                        ,_nb_front_end,_nb_decod_unit[it1]);
2314    DELETE2(_link_thread_with_context                               ,_nb_front_end,_nb_context[it1]);
2315
2316    log_end(Core,FUNCTION);
2317  };
2318
2319#undef  FUNCTION
2320#define FUNCTION "Core::copy"
2321  void Parameters::copy (void) 
2322  {
2323    log_begin(Core,FUNCTION);
2324
2325    for (uint32_t i=0; i<_nb_front_end; ++i)
2326    COPY(_param_front_end [i]);
2327    for (uint32_t i=0; i<_nb_ooo_engine; ++i)
2328    COPY(_param_ooo_engine [i]);
2329    for (uint32_t i=0; i<_nb_execute_loop; ++i)
2330    COPY(_param_execute_loop [i]);
2331    COPY(_param_icache_access);
2332    COPY(_param_dcache_access);
2333    COPY(_param_glue);
2334
2335    log_end(Core,FUNCTION);
2336  };
2337
2338}; // end namespace core
2339}; // end namespace behavioural
2340}; // end namespace morpheo             
Note: See TracBrowser for help on using the repository browser.