Context Navigation

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

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

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

Download in other formats: