Context Navigation

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

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: