Context Navigation

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

Last change on this file since 123 was 123, checked in by rosiere, 15 years ago
1) Fix performance 2) add auto generation to SPECINT2000 3) add reset in genMoore and genMealy
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: