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

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

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