Context Navigation

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

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

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

Download in other formats: