Context Navigation

main.cpp @ 146

Last change on this file since 146 was 146, checked in by rosiere, 13 years ago
1) Integration of RegisterFile_Internal_Banked in RegisterFile? 2) Erase "read_write" interface in RegisterFile_Monolithic component 3) Add smith predictor parameters in Load_store_pointer_unit. 4) Fix not statistics flags
Property svn:keywords set to `Id`
File size: 56.6 KB

Line
1	/*
2	* $Id: main.cpp 146 2011-02-01 20:57:54Z rosiere $
3	*
4	* [ Description ]
5	*
6	*/
7
8	#include "Behavioural/Core/SelfTest/include/test.h"
9	#include "Common/include/Max.h"
10
11	#define NB_PARAMS 20
12
13	void usage (int argc, char * argv[])
14	{
15	err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
16	err (_("list_params is :\n"));
17	err (_(" * size_general_data (uint32_t )\n"));
18	err (_(" * size_special_data (uint32_t )\n"));
19	//morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
20
21	err (_(" * nb_thread (uint32_t )\n"));
22	err (_(" * size_ifetch_queue [nb_thread] (uint32_t )\n"));
23	err (_(" * nb_inst_fetch [nb_thread] (uint32_t )\n"));
24	//err (_(" * implement_group [nb_thread][NB_GROUP] (bool )\n"));
25	err (_(" * ras_size_queue [nb_thread] (uint32_t )\n"));
26	err (_(" * upt_size_queue [nb_thread] (uint32_t )\n"));
27	err (_(" * ufpt_size_queue [nb_thread] (uint32_t )\n"));
28
29	err (_(" * nb_decod_bloc (uint32_t )\n"));
30	err (_(" * size_decod_queue [nb_decod_bloc] (uint32_t )\n"));
31	err (_(" * decod_queue_scheme [nb_decod_bloc] (Tdecod_queue_scheme_t)\n"));
32	err (_(" * nb_inst_decod [nb_decod_bloc] (uint32_t )\n"));
33	err (_(" * nb_context_select [nb_decod_bloc] (uint32_t )\n"));
34	err (_(" * context_select_priority [nb_decod_bloc] (Tpriority_t )\n"));
35	err (_(" * context_select_load_balancing [nb_decod_bloc] (Tload_balancing_t )\n"));
36
37	err (_(" * nb_rename_bloc (uint32_t )\n"));
38	err (_(" * nb_inst_insert [nb_rename_bloc] (uint32_t )\n"));
39	err (_(" * nb_inst_retire [nb_rename_bloc] (uint32_t )\n"));
40	err (_(" * rename_select_priority [nb_rename_bloc] (Tpriority_t )\n"));
41	err (_(" * rename_select_load_balancing [nb_rename_bloc] (Tload_balancing_t )\n"));
42	err (_(" * rename_select_nb_front_end_select [nb_rename_bloc] (uint32_t )\n"));
43	err (_(" * nb_general_register [nb_rename_bloc] (uint32_t )\n"));
44	err (_(" * nb_special_register [nb_rename_bloc] (uint32_t )\n"));
45	err (_(" * nb_reg_free [nb_rename_bloc] (uint32_t )\n"));
46	err (_(" * nb_rename_unit_bank [nb_rename_bloc] (uint32_t )\n"));
47	// err (_(" * size_read_counter [nb_rename_bloc] (uint32_t )\n"));
48
49	err (_(" * nb_read_bloc (uint32_t )\n"));
50	err (_(" * size_read_queue [nb_read_bloc] (uint32_t )\n"));
51	err (_(" * size_reservation_station [nb_read_bloc] (uint32_t )\n"));
52	err (_(" * nb_inst_retire_reservation_station [nb_read_bloc] (uint32_t )\n"));
53
54	err (_(" * nb_write_bloc (uint32_t )\n"));
55	err (_(" * size_write_queue [nb_write_bloc] (uint32_t )\n"));
56	err (_(" * size_execute_queue [nb_write_bloc] (uint32_t )\n"));
57	err (_(" * nb_bypass_write [nb_write_bloc] (uint32_t )\n"));
58	err (_(" * write_queue_scheme [nb_write_bloc] (Twrite_queue_scheme_t)\n"));
59
60	err (_(" * nb_load_store_unit (uint32_t )\n"));
61	err (_(" * size_store_queue [nb_load_store_unit] (uint32_t )\n"));
62	err (_(" * size_load_queue [nb_load_store_unit] (uint32_t )\n"));
63	err (_(" * size_speculative_access_queue [nb_load_store_unit] (uint32_t )\n"));
64	err (_(" * nb_port_check [nb_load_store_unit] (uint32_t )\n"));
65	err (_(" * speculative_load [nb_load_store_unit] (Tspeculative_load )\n"));
66	err (_(" * nb_bypass_memory [nb_load_store_unit] (uint32_t )\n"));
67	err (_(" * nb_cache_port [nb_load_store_unit] (uint32_t )\n"));
68	err (_(" * nb_inst_memory [nb_load_store_unit] (uint32_t )\n"));
69
70	err (_(" * nb_functionnal_unit (uint32_t )\n"));
71	err (_(" * nb_inst_functionnal_unit [nb_functionnal_unit] (uint32_t )\n"));
72	//err (_(" * timing [nb_functionnal_unit][nb_type][nb_operation] (execute_timing_t )\n"));
73
74	err (_(" * nb_icache_port (uint32_t )\n"));
75	err (_(" * icache_port_priority (Tpriority_t )\n"));
76	err (_(" * icache_port_load_balancing (Tload_balancing_t )\n"));
77
78	err (_(" * nb_dcache_port (uint32_t )\n"));
79	err (_(" * dcache_port_priority (Tpriority_t )\n"));
80	err (_(" * dcache_port_load_balancing (Tload_balancing_t )\n"));
81
82	err (_(" * nb_front_end (uint32_t )\n"));
83	err (_(" * nb_context [nb_front_end] (uint32_t )\n"));
84	err (_(" * nb_decod_unit [nb_front_end] (uint32_t )\n"));
85	err (_(" * nb_inst_branch_predict [nb_front_end] (uint32_t )\n"));
86	err (_(" * nb_inst_branch_decod [nb_front_end] (uint32_t )\n"));
87	err (_(" * nb_inst_branch_update [nb_front_end] (uint32_t )\n"));
88	err (_(" * btb_size_queue [nb_front_end] (uint32_t )\n"));
89	err (_(" * btb_associativity [nb_front_end] (uint32_t )\n"));
90	err (_(" * btb_size_counter [nb_front_end] (uint32_t )\n"));
91	err (_(" * btb_victim_scheme [nb_front_end] (Tvictim_t )\n"));
92	err (_(" * dir_predictor_scheme [nb_front_end] (Tpredictor_t )\n"));
93	err (_(" * dir_have_bht [nb_front_end][3] (bool )\n"));
94	err (_(" * dir_bht_size_shifter [nb_front_end][3] (uint32_t )\n"));
95	err (_(" * dir_bht_nb_shifter [nb_front_end][3] (uint32_t )\n"));
96	err (_(" * dir_have_pht [nb_front_end][3] (bool )\n"));
97	err (_(" * dir_pht_size_counter [nb_front_end][3] (uint32_t )\n"));
98	err (_(" * dir_pht_nb_counter [nb_front_end][3] (uint32_t )\n"));
99	err (_(" * dir_pht_size_address_share [nb_front_end][3] (uint32_t )\n"));
100	err (_(" * dir_pht_scheme [nb_front_end][3] (Tpht_scheme_t )\n"));
101	err (_(" * nb_ooo_engine (uint32_t )\n"));
102	err (_(" * nb_rename_unit [nb_ooo_engine] (uint32_t )\n"));
103	err (_(" * nb_inst_issue [nb_ooo_engine] (uint32_t )\n"));
104	err (_(" * nb_inst_reexecute [nb_ooo_engine] (uint32_t )\n"));
105	err (_(" * nb_inst_commit [nb_ooo_engine] (uint32_t )\n"));
106	err (_(" * nb_inst_branch_complete [nb_ooo_engine] (uint32_t )\n"));
107	err (_(" * nb_rename_unit_select [nb_ooo_engine] (uint32_t )\n"));
108	err (_(" * nb_execute_loop_select [nb_ooo_engine] (uint32_t )\n"));
109	err (_(" * size_re_order_buffer [nb_ooo_engine] (uint32_t )\n"));
110	err (_(" * nb_re_order_buffer_bank [nb_ooo_engine] (uint32_t )\n"));
111	err (_(" * commit_priority [nb_ooo_engine] (Tpriority_t )\n"));
112	err (_(" * commit_load_balancing [nb_ooo_engine] (Tload_balancing_t )\n"));
113	err (_(" * size_issue_queue [nb_ooo_engine] (uint32_t )\n"));
114	err (_(" * issue_queue_scheme [nb_ooo_engine] (Tissue_queue_scheme_t)\n"));
115	err (_(" * nb_issue_queue_bank [nb_ooo_engine] (uint32_t )\n"));
116	err (_(" * issue_priority [nb_ooo_engine] (Tpriority_t )\n"));
117	err (_(" * issue_load_balancing [nb_ooo_engine] (Tload_balancing_t )\n"));
118	err (_(" * size_reexecute_queue [nb_ooo_engine] (uint32_t )\n"));
119	err (_(" * reexecute_priority [nb_ooo_engine] (Tpriority_t )\n"));
120	err (_(" * reexecute_load_balancing [nb_ooo_engine] (Tload_balancing_t )\n"));
121
122	err (_(" * nb_execute_loop (uint32_t )\n"));
123	err (_(" * nb_read_unit [nb_execute_loop] (uint32_t )\n"));
124	err (_(" * nb_execute_unit [nb_execute_loop] (uint32_t )\n"));
125	err (_(" * nb_write_unit [nb_execute_loop] (uint32_t )\n"));
126	err (_(" * nb_gpr_bank [nb_execute_loop] (uint32_t )\n"));
127	err (_(" * nb_gpr_port_read_by_bank [nb_execute_loop] (uint32_t )\n"));
128	err (_(" * nb_gpr_port_write_by_bank [nb_execute_loop] (uint32_t )\n"));
129	err (_(" * nb_spr_bank [nb_execute_loop] (uint32_t )\n"));
130	err (_(" * nb_spr_port_read_by_bank [nb_execute_loop] (uint32_t )\n"));
131	err (_(" * nb_spr_port_write_by_bank [nb_execute_loop] (uint32_t )\n"));
132	err (_(" * execution_unit_to_write_unit_priority [nb_execute_loop] (Tpriority_t )\n"));
133	err (_(" * read_unit_to_execution_unit_priority [nb_execute_loop] (Tpriority_t )\n"));
134
135	err (_(" * link_context_with_thread [nb_thread] (pair_dual )\n"));
136	err (_(" * link_decod_unit_with_decod_bloc [nb_decod_bloc] (pair_dual )\n"));
137	err (_(" * link_rename_unit_with_rename_bloc [nb_rename_bloc] (pair_dual )\n"));
138	err (_(" * link_read_unit_with_read_bloc [nb_read_bloc] (pair_dual )\n"));
139	err (_(" * link_write_unit_with_write_bloc [nb_write_bloc] (pair_dual )\n"));
140	err (_(" * link_execute_unit_with_functionnal_unit [nb_functionnal_unit] (pair_dual )\n"));
141	err (_(" * link_execute_unit_with_load_store_unit [nb_load_store_unit] (pair_dual )\n"));
142	err (_(" * link_decod_bloc_with_thread [nb_thread] (uint32_t )\n"));
143	err (_(" * link_rename_bloc_with_front_end [nb_front_end] (uint32_t )\n"));
144	err (_(" * table_dispatch [nb_ooo_engine][nb_inst_issue][nb_read_bloc] (bool )\n"));
145	err (_(" * link_read_bloc_and_load_store_unit [nb_read_bloc][nb_load_store_unit] (bool )\n"));
146	err (_(" * link_read_bloc_and_functionnal_unit [nb_read_bloc][nb_functionnal_unit] (bool )\n"));
147	err (_(" * link_write_bloc_and_load_store_unit [nb_write_bloc][nb_load_store_unit] (bool )\n"));
148	err (_(" * link_write_bloc_and_functionnal_unit [nb_write_bloc][nb_functionnal_unit] (bool )\n"));
149	err (_(" * link_load_store_unit_with_thread [nb_thread] (uint32_t )\n"));
150	err (_(" * link_thread_and_functionnal_unit [nb_thread][nb_functionnal_unit] (bool )\n"));
151	err (_(" * link_icache_port_with_thread [nb_thread] (uint32_t )\n"));
152	err (_(" * link_dcache_port_with_load_store_unit [nb_load_store_unit][nb_cache_port] (uint32_t )\n"));
153
154	err (_(" * dispatch_priority (Tpriority_t )\n"));
155	err (_(" * dispatch_load_balancing (Tload_balancing_t )\n"));
156	err (_("\n"));
157	err (_(" - pair_dual : first = x div 1000, second = x mod 1000\n"));
158	err (_("\n"));
159	err (_(" - now they have %d\n"),argc);
160
161	exit (1);
162	}
163
164	#ifndef SYSTEMC
165	int main (int argc, char * argv[])
166	#else
167	int sc_main (int argc, char * argv[])
168	#endif
169	{
170	if (argc < static_cast<int>(2+NB_PARAMS))
171	usage (argc, argv);
172
173	uint32_t x = 1;
174
175	string name = argv[x++];
176
177	// Common
178	uint32_t _size_general_data ;
179	uint32_t _size_special_data ;
180	morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void);
181
182	// Thread
183	uint32_t _nb_thread ;
184	uint32_t * _size_ifetch_queue ;//[nb_thread]
185	uint32_t * _nb_inst_fetch ;//[nb_thread]
186	bool ** _implement_group ;//[nb_thread][NB_GROUP]
187	uint32_t * _ras_size_queue ;//[nb_thread]
188	uint32_t * _upt_size_queue ;//[nb_thread]
189	uint32_t * _ufpt_size_queue ;//[nb_thread]
190
191	// Decod_bloc
192	uint32_t _nb_decod_bloc ;//
193	uint32_t * _size_decod_queue ;//[nb_decod_bloc]
194	multi_front_end::front_end::decod_unit::decod_queue::Tdecod_queue_scheme_t
195	* _decod_queue_scheme ;//[nb_decod_bloc]
196	uint32_t * _nb_inst_decod ;//[nb_decod_bloc]
197	uint32_t * _nb_context_select ;//[nb_decod_bloc]
198	Tpriority_t * _context_select_priority ;//[nb_decod_bloc]
199	Tload_balancing_t * _context_select_load_balancing ;//[nb_decod_bloc]
200
201	// Rename_bloc
202	uint32_t _nb_rename_bloc ;//
203	uint32_t * _nb_inst_insert ;//[nb_rename_bloc]
204	uint32_t * _nb_inst_retire ;//[nb_rename_bloc]
205	Tpriority_t * _rename_select_priority ;//[nb_rename_bloc]
206	Tload_balancing_t * _rename_select_load_balancing ;//[nb_rename_bloc]
207	uint32_t * _rename_select_nb_front_end_select ;//[nb_rename_bloc]
208	uint32_t * _nb_general_register ;//[nb_rename_bloc]
209	uint32_t * _nb_special_register ;//[nb_rename_bloc]
210	uint32_t * _nb_reg_free ;//[nb_rename_bloc]
211	uint32_t * _nb_rename_unit_bank ;//[nb_rename_bloc]
212	// uint32_t * _size_read_counter ;//[nb_rename_bloc]
213
214	// Read bloc
215	uint32_t _nb_read_bloc ;//
216	uint32_t * _size_read_queue ;//[nb_read_bloc]
217	uint32_t * _size_reservation_station ;//[nb_read_bloc]
218	uint32_t * _nb_inst_retire_reservation_station ;//[nb_read_bloc]
219
220	// Write bloc
221	uint32_t _nb_write_bloc ;//
222	uint32_t * _size_write_queue ;//[nb_write_bloc]
223	uint32_t * _size_execute_queue ;//[nb_write_bloc]
224	uint32_t * _nb_bypass_write ;//[nb_write_bloc]
225	core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t * _write_queue_scheme; //[nb_write_bloc]
226
227	// Load_store_unit
228	uint32_t _nb_load_store_unit ;
229	uint32_t * _size_store_queue ;//[nb_load_store_unit]
230	uint32_t * _size_load_queue ;//[nb_load_store_unit]
231	uint32_t * _size_speculative_access_queue ;//[nb_load_store_unit]
232	uint32_t * _nb_port_check ;//[nb_load_store_unit]
233	multi_execute_loop::execute_loop::Tspeculative_load_t
234	* _speculative_load ;//[nb_load_store_unit]
235	uint32_t * _nb_bypass_memory ;//[nb_load_store_unit]
236	uint32_t * _nb_cache_port ;//[nb_load_store_unit]
237	uint32_t * _nb_inst_memory ;//[nb_load_store_unit]
238
239	// Functionnal_unit
240	uint32_t _nb_functionnal_unit ;
241	uint32_t * _nb_inst_functionnal_unit ;//[nb_functionnal_unit]
242	multi_execute_loop::execute_loop::execute_timing_t
243	*** _timing ;//[nb_functionnal_unit][nb_type][nb_operation]
244
245	// Icache_Access
246	uint32_t _nb_icache_port ;
247	Tpriority_t _icache_port_priority ;
248	Tload_balancing_t _icache_port_load_balancing ;
249
250	// Dcache_Access
251	uint32_t _nb_dcache_port ;
252	Tpriority_t _dcache_port_priority ;
253	Tload_balancing_t _dcache_port_load_balancing ;
254
255	// Front_end
256	uint32_t _nb_front_end ;
257	uint32_t * _nb_context ;//[nb_front_end]
258	uint32_t * _nb_decod_unit ;//[nb_front_end]
259	uint32_t * _nb_inst_branch_predict ;//[nb_front_end]
260	uint32_t * _nb_inst_branch_decod ;//[nb_front_end]
261	uint32_t * _nb_inst_branch_update ;//[nb_front_end]
262	uint32_t * _btb_size_queue ;//[nb_front_end]
263	uint32_t * _btb_associativity ;//[nb_front_end]
264	uint32_t * _btb_size_counter ;//[nb_front_end]
265	Tvictim_t * _btb_victim_scheme ;//[nb_front_end]
266	Tpredictor_t * _dir_predictor_scheme ;//[nb_front_end]
267	bool ** _dir_have_bht ;//[nb_front_end][3]
268	uint32_t ** _dir_bht_size_shifter ;//[nb_front_end][3]
269	uint32_t ** _dir_bht_nb_shifter ;//[nb_front_end][3]
270	bool ** _dir_have_pht ;//[nb_front_end][3]
271	uint32_t ** _dir_pht_size_counter ;//[nb_front_end][3]
272	uint32_t ** _dir_pht_nb_counter ;//[nb_front_end][3]
273	uint32_t ** _dir_pht_size_address_share ;//[nb_front_end][3]
274	Tpht_scheme_t ** _dir_pht_scheme ;//[nb_front_end][3]
275
276	// OOO_Engine
277	uint32_t _nb_ooo_engine ;
278	uint32_t * _nb_rename_unit ;//[nb_ooo_engine]
279	uint32_t * _nb_inst_issue ;//[nb_ooo_engine]
280	uint32_t * _nb_inst_reexecute ;//[nb_ooo_engine]
281	uint32_t * _nb_inst_commit ;//[nb_ooo_engine]
282	uint32_t * _nb_inst_branch_complete ;//[nb_ooo_engine]
283	uint32_t * _nb_rename_unit_select ;//[nb_ooo_engine]
284	uint32_t * _nb_execute_loop_select ;//[nb_ooo_engine]
285	uint32_t * _size_re_order_buffer ;//[nb_ooo_engine]
286	uint32_t * _nb_re_order_buffer_bank ;//[nb_ooo_engine]
287	Tpriority_t * _commit_priority ;//[nb_ooo_engine]
288	Tload_balancing_t * _commit_load_balancing ;//[nb_ooo_engine]
289	uint32_t * _size_issue_queue ;//[nb_ooo_engine]
290	multi_ooo_engine::ooo_engine::issue_queue::Tissue_queue_scheme_t
291	* _issue_queue_scheme ;//[nb_ooo_engine]
292	uint32_t * _nb_issue_queue_bank ;//[nb_ooo_engine]
293	Tpriority_t * _issue_priority ;//[nb_ooo_engine]
294	Tload_balancing_t * _issue_load_balancing ;//[nb_ooo_engine]
295	uint32_t * _size_reexecute_queue ;//[nb_ooo_engine]
296	Tpriority_t * _reexecute_priority ;//[nb_ooo_engine]
297	Tload_balancing_t * _reexecute_load_balancing ;//[nb_ooo_engine]
298
299	// Execute_loop
300	uint32_t _nb_execute_loop ;
301	uint32_t * _nb_read_unit ;//[nb_execute_loop]
302	uint32_t * _nb_execute_unit ;//[nb_execute_loop]
303	uint32_t * _nb_write_unit ;//[nb_execute_loop]
304	uint32_t * _nb_gpr_bank ;//[nb_execute_loop]
305	uint32_t * _nb_gpr_port_read_by_bank ;//[nb_execute_loop]
306	uint32_t * _nb_gpr_port_write_by_bank ;//[nb_execute_loop]
307	uint32_t * _nb_spr_bank ;//[nb_execute_loop]
308	uint32_t * _nb_spr_port_read_by_bank ;//[nb_execute_loop]
309	uint32_t * _nb_spr_port_write_by_bank ;//[nb_execute_loop]
310	Tpriority_t * _execution_unit_to_write_unit_priority ;//[nb_execute_loop]
311	Tpriority_t * _read_unit_to_execution_unit_priority ;//[nb_execute_loop]
312
313	// Link
314	pair_dual * _link_context_with_thread ;//[nb_thread]
315	pair_dual * _link_decod_unit_with_decod_bloc ;//[nb_decod_bloc]
316	pair_dual * _link_rename_unit_with_rename_bloc ;//[nb_rename_bloc]
317	pair_dual * _link_read_unit_with_read_bloc ;//[nb_read_bloc]
318	pair_dual * _link_write_unit_with_write_bloc ;//[nb_write_bloc]
319	pair_dual * _link_execute_unit_with_functionnal_unit ;//[nb_functionnal_unit]
320	pair_dual * _link_execute_unit_with_load_store_unit ;//[nb_load_store_unit]
321	uint32_t * _link_decod_bloc_with_thread ;//[nb_thread]
322	uint32_t * _link_rename_bloc_with_front_end ;//[nb_front_end]
323	bool *** _table_dispatch ;//[nb_ooo_engine][nb_inst_issue][nb_read_bloc]
324	bool ** _link_read_bloc_and_load_store_unit ;//[nb_read_bloc][nb_load_store_unit]
325	bool ** _link_read_bloc_and_functionnal_unit ;//[nb_read_bloc][nb_functionnal_unit]
326	bool ** _link_write_bloc_and_load_store_unit ;//[nb_write_bloc][nb_load_store_unit]
327	bool ** _link_write_bloc_and_functionnal_unit ;//[nb_write_bloc][nb_functionnal_unit]
328	uint32_t * _link_load_store_unit_with_thread ;//[nb_thread]
329	bool ** _link_thread_and_functionnal_unit ;//[nb_thread][nb_functionnal_unit]
330	uint32_t * _link_icache_port_with_thread ;//[nb_thread]
331	uint32_t ** _link_dcache_port_with_load_store_unit ;//[nb_load_store_unit][nb_cache_port]
332
333	Tpriority_t _dispatch_priority ;
334	Tload_balancing_t _dispatch_load_balancing ;
335
336	printf("Core parameters :\n");
337
338	// Common
339	printf(" * Common\n");
340	SELFTEST0(_size_general_data ,uint32_t ,argv,x);
341	SELFTEST0(_size_special_data ,uint32_t ,argv,x);
342	_get_custom_information = &(morpheo::behavioural::custom::default_get_custom_information);
343
344	//Thread
345	printf(" * Thread\n");
346	SELFTEST0(_nb_thread ,uint32_t ,argv,x);
347
348	if (argc < static_cast<int>(2+NB_PARAMS+5*_nb_thread))
349	usage (argc, argv);
350
351	SELFTEST1(_size_ifetch_queue ,uint32_t ,argv,x,_nb_thread);
352	SELFTEST1(_nb_inst_fetch ,uint32_t ,argv,x,_nb_thread);
353	ALLOC2 (_implement_group ,bool ,_nb_thread,NB_GROUP);
354	for (uint32_t i=0; i<_nb_thread; ++i)
355	for (uint32_t j=0; j<NB_GROUP; ++j)
356	_implement_group[i][j] = true;
357	SELFTEST1(_ras_size_queue ,uint32_t ,argv,x,_nb_thread);
358	SELFTEST1(_upt_size_queue ,uint32_t ,argv,x,_nb_thread);
359	SELFTEST1(_ufpt_size_queue ,uint32_t ,argv,x,_nb_thread);
360
361	// Decod bloc
362	printf(" * Decod bloc\n");
363	SELFTEST0(_nb_decod_bloc ,uint32_t ,argv,x);
364
365	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc))
366	usage (argc, argv);
367
368	SELFTEST1(_size_decod_queue ,uint32_t ,argv,x,_nb_decod_bloc);
369	SELFTEST1(_decod_queue_scheme ,multi_front_end::front_end::decod_unit::decod_queue::Tdecod_queue_scheme_t,argv,x,_nb_decod_bloc);
370	SELFTEST1(_nb_inst_decod ,uint32_t ,argv,x,_nb_decod_bloc);
371	SELFTEST1(_nb_context_select ,uint32_t ,argv,x,_nb_decod_bloc);
372	SELFTEST1(_context_select_priority ,Tpriority_t ,argv,x,_nb_decod_bloc);
373	SELFTEST1(_context_select_load_balancing ,Tload_balancing_t ,argv,x,_nb_decod_bloc);
374
375	// Rename bloc
376	printf(" * Rename bloc\n");
377	SELFTEST0(_nb_rename_bloc ,uint32_t ,argv,x);
378
379	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9*_nb_rename_bloc))
380	usage (argc, argv);
381
382	SELFTEST1(_nb_inst_insert ,uint32_t ,argv,x,_nb_rename_bloc);
383	SELFTEST1(_nb_inst_retire ,uint32_t ,argv,x,_nb_rename_bloc);
384	SELFTEST1(_rename_select_priority ,Tpriority_t ,argv,x,_nb_rename_bloc);
385	SELFTEST1(_rename_select_load_balancing ,Tload_balancing_t ,argv,x,_nb_rename_bloc);
386	SELFTEST1(_rename_select_nb_front_end_select ,uint32_t ,argv,x,_nb_rename_bloc);
387	SELFTEST1(_nb_general_register ,uint32_t ,argv,x,_nb_rename_bloc);
388	SELFTEST1(_nb_special_register ,uint32_t ,argv,x,_nb_rename_bloc);
389	SELFTEST1(_nb_reg_free ,uint32_t ,argv,x,_nb_rename_bloc);
390	SELFTEST1(_nb_rename_unit_bank ,uint32_t ,argv,x,_nb_rename_bloc);
391	// SELFTEST1(_size_read_counter ,uint32_t ,argv,x,_nb_rename_bloc);
392
393	// Read bloc
394	printf(" * Read bloc\n");
395	SELFTEST0(_nb_read_bloc ,uint32_t ,argv,x);
396
397	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc))
398	usage (argc, argv);
399
400	SELFTEST1(_size_read_queue ,uint32_t ,argv,x,_nb_read_bloc);
401	SELFTEST1(_size_reservation_station ,uint32_t ,argv,x,_nb_read_bloc);
402	SELFTEST1(_nb_inst_retire_reservation_station ,uint32_t ,argv,x,_nb_read_bloc);
403
404	// Write bloc
405	printf(" * Write bloc\n");
406	SELFTEST0(_nb_write_bloc ,uint32_t ,argv,x);
407
408	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc+4*_nb_write_bloc))
409	usage (argc, argv);
410
411	SELFTEST1(_size_write_queue ,uint32_t ,argv,x,_nb_write_bloc);
412	SELFTEST1(_size_execute_queue ,uint32_t ,argv,x,_nb_write_bloc);
413	SELFTEST1(_nb_bypass_write ,uint32_t ,argv,x,_nb_write_bloc);
414	SELFTEST1(_write_queue_scheme,core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t,argv,x,_nb_write_bloc);
415
416	// Load store unit
417	printf(" * Load store unit\n");
418	SELFTEST0(_nb_load_store_unit ,uint32_t ,argv,x);
419
420	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc+4_nb_write_bloc+8_nb_load_store_unit))
421	usage (argc, argv);
422
423	SELFTEST1(_size_store_queue ,uint32_t ,argv,x,_nb_load_store_unit);
424	SELFTEST1(_size_load_queue ,uint32_t ,argv,x,_nb_load_store_unit);
425	SELFTEST1(_size_speculative_access_queue ,uint32_t ,argv,x,_nb_load_store_unit);
426	SELFTEST1(_nb_port_check ,uint32_t ,argv,x,_nb_load_store_unit);
427	SELFTEST1(_speculative_load ,multi_execute_loop::execute_loop::Tspeculative_load_t
428	,argv,x,_nb_load_store_unit);
429	SELFTEST1(_nb_bypass_memory ,uint32_t ,argv,x,_nb_load_store_unit);
430	SELFTEST1(_nb_cache_port ,uint32_t ,argv,x,_nb_load_store_unit);
431	SELFTEST1(_nb_inst_memory ,uint32_t ,argv,x,_nb_load_store_unit);
432
433	// Functionnal_unit
434	printf(" * Functional unit\n");
435	SELFTEST0(_nb_functionnal_unit ,uint32_t ,argv,x);
436
437	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc+4_nb_write_bloc+8_nb_load_store_unit+1*_nb_functionnal_unit))
438	usage (argc, argv);
439
440	SELFTEST1(_nb_inst_functionnal_unit ,uint32_t ,argv,x,_nb_functionnal_unit);
441	ALLOC3 (_timing ,multi_execute_loop::execute_loop::execute_timing_t,_nb_functionnal_unit,MAX_TYPE,MAX_OPERATION);
442
443	for (uint32_t i=0; i< _nb_functionnal_unit; i++)
444	for (uint32_t j=0; j< MAX_TYPE; j++)
445	if ((j == TYPE_ALU ) \|
446	(j == TYPE_SHIFT ) \|
447	(j == TYPE_MOVE ) \|
448	(j == TYPE_TEST ) \|
449	(j == TYPE_MUL ) \|
450	(j == TYPE_DIV ) \|
451	(j == TYPE_EXTEND ) \|
452	(j == TYPE_FIND ) \|
453	(j == TYPE_SPECIAL) \|
454	(j == TYPE_CUSTOM ) \|
455	(j == TYPE_BRANCH ) // \|
456	// (j == TYPE_MEMORY )
457	)
458	for (uint32_t k=0; k< MAX_OPERATION; k++)
459	_timing [i][j][k]._delay = _timing [i][j][k]._latence = 1;
460
461	// Icache_Access
462	printf(" * Icache access\n");
463
464	SELFTEST0(_nb_icache_port ,uint32_t ,argv,x);
465	SELFTEST0(_icache_port_priority ,Tpriority_t ,argv,x);
466	SELFTEST0(_icache_port_load_balancing ,Tload_balancing_t ,argv,x);
467
468	// Dcache_Access
469	printf(" * Dcache access\n");
470
471	SELFTEST0(_nb_dcache_port ,uint32_t ,argv,x);
472	SELFTEST0(_dcache_port_priority ,Tpriority_t ,argv,x);
473	SELFTEST0(_dcache_port_load_balancing ,Tload_balancing_t ,argv,x);
474
475	// Front_end
476	printf(" * Front end\n");
477
478	SELFTEST0(_nb_front_end ,uint32_t ,argv,x);
479
480	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc+4_nb_write_bloc+8_nb_load_store_unit+1_nb_functionnal_unit+31_nb_front_end))
481	usage (argc, argv);
482
483	SELFTEST1(_nb_context ,uint32_t ,argv,x,_nb_front_end);
484	SELFTEST1(_nb_decod_unit ,uint32_t ,argv,x,_nb_front_end);
485	SELFTEST1(_nb_inst_branch_predict ,uint32_t ,argv,x,_nb_front_end);
486	SELFTEST1(_nb_inst_branch_decod ,uint32_t ,argv,x,_nb_front_end);
487	SELFTEST1(_nb_inst_branch_update ,uint32_t ,argv,x,_nb_front_end);
488	SELFTEST1(_btb_size_queue ,uint32_t ,argv,x,_nb_front_end);
489	SELFTEST1(_btb_associativity ,uint32_t ,argv,x,_nb_front_end);
490	SELFTEST1(_btb_size_counter ,uint32_t ,argv,x,_nb_front_end);
491	SELFTEST1(_btb_victim_scheme ,Tvictim_t ,argv,x,_nb_front_end);
492	SELFTEST1(_dir_predictor_scheme ,Tpredictor_t ,argv,x,_nb_front_end);
493
494	SELFTEST2(_dir_have_bht ,bool ,argv,x,_nb_front_end,3);
495	SELFTEST2(_dir_bht_size_shifter ,uint32_t ,argv,x,_nb_front_end,3);
496	SELFTEST2(_dir_bht_nb_shifter ,uint32_t ,argv,x,_nb_front_end,3);
497	SELFTEST2(_dir_have_pht ,bool ,argv,x,_nb_front_end,3);
498	SELFTEST2(_dir_pht_size_counter ,uint32_t ,argv,x,_nb_front_end,3);
499	SELFTEST2(_dir_pht_nb_counter ,uint32_t ,argv,x,_nb_front_end,3);
500	SELFTEST2(_dir_pht_size_address_share ,uint32_t ,argv,x,_nb_front_end,3);
501	SELFTEST2(_dir_pht_scheme ,Tpht_scheme_t ,argv,x,_nb_front_end,3);
502
503	// OOO_Engine
504	printf(" * OOO Engine\n");
505
506	SELFTEST0(_nb_ooo_engine ,uint32_t ,argv,x);
507
508	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc+4_nb_write_bloc+8_nb_load_store_unit+1_nb_functionnal_unit+31_nb_front_end+19*_nb_ooo_engine))
509	usage (argc, argv);
510
511	SELFTEST1(_nb_rename_unit ,uint32_t ,argv,x,_nb_ooo_engine);
512	SELFTEST1(_nb_inst_issue ,uint32_t ,argv,x,_nb_ooo_engine);
513	SELFTEST1(_nb_inst_reexecute ,uint32_t ,argv,x,_nb_ooo_engine);
514	SELFTEST1(_nb_inst_commit ,uint32_t ,argv,x,_nb_ooo_engine);
515	SELFTEST1(_nb_inst_branch_complete ,uint32_t ,argv,x,_nb_ooo_engine);
516	SELFTEST1(_nb_rename_unit_select ,uint32_t ,argv,x,_nb_ooo_engine);
517	SELFTEST1(_nb_execute_loop_select ,uint32_t ,argv,x,_nb_ooo_engine);
518	SELFTEST1(_size_re_order_buffer ,uint32_t ,argv,x,_nb_ooo_engine);
519	SELFTEST1(_nb_re_order_buffer_bank ,uint32_t ,argv,x,_nb_ooo_engine);
520	SELFTEST1(_commit_priority ,Tpriority_t ,argv,x,_nb_ooo_engine);
521	SELFTEST1(_commit_load_balancing ,Tload_balancing_t ,argv,x,_nb_ooo_engine);
522	SELFTEST1(_size_issue_queue ,uint32_t ,argv,x,_nb_ooo_engine);
523	SELFTEST1(_issue_queue_scheme ,multi_ooo_engine::ooo_engine::issue_queue::Tissue_queue_scheme_t,argv,x,_nb_ooo_engine);
524	SELFTEST1(_nb_issue_queue_bank ,uint32_t ,argv,x,_nb_ooo_engine);
525	SELFTEST1(_issue_priority ,Tpriority_t ,argv,x,_nb_ooo_engine);
526	SELFTEST1(_issue_load_balancing ,Tload_balancing_t ,argv,x,_nb_ooo_engine);
527	SELFTEST1(_size_reexecute_queue ,uint32_t ,argv,x,_nb_ooo_engine);
528	SELFTEST1(_reexecute_priority ,Tpriority_t ,argv,x,_nb_ooo_engine);
529	SELFTEST1(_reexecute_load_balancing ,Tload_balancing_t ,argv,x,_nb_ooo_engine);
530
531	//Execute_loop
532	printf(" * Execute Loop\n");
533
534	SELFTEST0(_nb_execute_loop ,uint32_t ,argv,x);
535
536	if (argc < static_cast<int>(2+NB_PARAMS+5_nb_thread+6_nb_decod_bloc+9_nb_rename_bloc+3_nb_read_bloc+4_nb_write_bloc+8_nb_load_store_unit+1_nb_functionnal_unit+31_nb_front_end+19_nb_ooo_engine+11_nb_execute_loop))
537	usage (argc, argv);
538
539	SELFTEST1(_nb_read_unit ,uint32_t ,argv,x,_nb_execute_loop);
540	SELFTEST1(_nb_execute_unit ,uint32_t ,argv,x,_nb_execute_loop);
541	SELFTEST1(_nb_write_unit ,uint32_t ,argv,x,_nb_execute_loop);
542	SELFTEST1(_nb_gpr_bank ,uint32_t ,argv,x,_nb_execute_loop);
543	SELFTEST1(_nb_gpr_port_read_by_bank ,uint32_t ,argv,x,_nb_execute_loop);
544	SELFTEST1(_nb_gpr_port_write_by_bank ,uint32_t ,argv,x,_nb_execute_loop);
545	SELFTEST1(_nb_spr_bank ,uint32_t ,argv,x,_nb_execute_loop);
546	SELFTEST1(_nb_spr_port_read_by_bank ,uint32_t ,argv,x,_nb_execute_loop);
547	SELFTEST1(_nb_spr_port_write_by_bank ,uint32_t ,argv,x,_nb_execute_loop);
548	SELFTEST1(_execution_unit_to_write_unit_priority ,Tpriority_t ,argv,x,_nb_execute_loop);
549	SELFTEST1(_read_unit_to_execution_unit_priority ,Tpriority_t ,argv,x,_nb_execute_loop);
550
551	// Link
552	printf(" * Link\n");
553
554	if (argc < static_cast<int>(2+NB_PARAMS+6_nb_thread+6_nb_decod_bloc+10_nb_rename_bloc+4_nb_read_bloc+5_nb_write_bloc+9_nb_load_store_unit+2_nb_functionnal_unit+31_nb_front_end+19_nb_ooo_engine+11_nb_execute_loop))
555	usage (argc, argv);
556
557	ALLOC1 (_link_context_with_thread ,pair_dual ,_nb_thread);
558	ALLOC1 (_link_decod_unit_with_decod_bloc ,pair_dual ,_nb_decod_bloc);
559	ALLOC1 (_link_rename_unit_with_rename_bloc ,pair_dual ,_nb_rename_bloc);
560	ALLOC1 (_link_read_unit_with_read_bloc ,pair_dual ,_nb_read_bloc);
561	ALLOC1 (_link_write_unit_with_write_bloc ,pair_dual ,_nb_write_bloc);
562	ALLOC1 (_link_execute_unit_with_functionnal_unit ,pair_dual ,_nb_functionnal_unit);
563	ALLOC1 (_link_execute_unit_with_load_store_unit ,pair_dual ,_nb_load_store_unit);
564
565	for (uint32_t i=0; i<_nb_thread; ++i)
566	{
567	uint32_t tmp=fromString<uint32_t>(argv[x++]);
568	_link_context_with_thread [i] = pair_dual(tmp/1000,tmp%1000);
569	}
570	for (uint32_t i=0; i<_nb_decod_bloc; ++i)
571	{
572	uint32_t tmp=fromString<uint32_t>(argv[x++]);
573	_link_decod_unit_with_decod_bloc [i] = pair_dual(tmp/1000,tmp%1000);
574	}
575	for (uint32_t i=0; i<_nb_rename_bloc; ++i)
576	{
577	uint32_t tmp=fromString<uint32_t>(argv[x++]);
578	_link_rename_unit_with_rename_bloc [i] = pair_dual(tmp/1000,tmp%1000);
579	}
580	for (uint32_t i=0; i<_nb_read_bloc; ++i)
581	{
582	uint32_t tmp=fromString<uint32_t>(argv[x++]);
583	_link_read_unit_with_read_bloc [i] = pair_dual(tmp/1000,tmp%1000);
584	}
585	for (uint32_t i=0; i<_nb_write_bloc; ++i)
586	{
587	uint32_t tmp=fromString<uint32_t>(argv[x++]);
588	_link_write_unit_with_write_bloc [i] = pair_dual(tmp/1000,tmp%1000);
589	}
590	for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
591	{
592	uint32_t tmp=fromString<uint32_t>(argv[x++]);
593	_link_execute_unit_with_functionnal_unit [i] = pair_dual(tmp/1000,tmp%1000);
594	}
595	for (uint32_t i=0; i<_nb_load_store_unit; ++i)
596	{
597	uint32_t tmp=fromString<uint32_t>(argv[x++]);
598	_link_execute_unit_with_load_store_unit [i] = pair_dual(tmp/1000,tmp%1000);
599	}
600
601	uint32_t _sum_inst_issue = 0;
602	for (uint32_t i=0; i<_nb_ooo_engine;++i)
603	_sum_inst_issue += _nb_inst_issue[i];
604	uint32_t _sum_cache_port = 0;
605	for (uint32_t i=0; i<_nb_load_store_unit;++i)
606	_sum_cache_port += _nb_cache_port[i];
607
608	if (argc != static_cast<int>(2+NB_PARAMS+6_nb_thread+6_nb_decod_bloc+10_nb_rename_bloc+4_nb_read_bloc+5_nb_write_bloc+9_nb_load_store_unit+2_nb_functionnal_unit+31_nb_front_end+19_nb_ooo_engine+11_nb_execute_loop+
609	3_nb_thread+_nb_front_end+_sum_inst_issue_nb_read_bloc+_nb_load_store_unit(_nb_read_bloc+_nb_write_bloc+_nb_thread)+_nb_functionnal_unit(_nb_read_bloc+_nb_write_bloc)+_sum_cache_port))
610	usage (argc, argv);
611
612	SELFTEST1(_link_decod_bloc_with_thread ,uint32_t ,argv,x,_nb_thread);
613	SELFTEST1(_link_rename_bloc_with_front_end ,uint32_t ,argv,x,_nb_front_end);
614	SELFTEST3(_table_dispatch ,bool ,argv,x,_nb_ooo_engine,_nb_inst_issue[it1],_nb_read_bloc);
615	SELFTEST2(_link_read_bloc_and_load_store_unit ,bool ,argv,x,_nb_read_bloc,_nb_load_store_unit);
616	SELFTEST2(_link_read_bloc_and_functionnal_unit ,bool ,argv,x,_nb_read_bloc,_nb_functionnal_unit);
617	SELFTEST2(_link_write_bloc_and_load_store_unit ,bool ,argv,x,_nb_write_bloc,_nb_load_store_unit);
618	SELFTEST2(_link_write_bloc_and_functionnal_unit ,bool ,argv,x,_nb_write_bloc,_nb_functionnal_unit);
619	SELFTEST1(_link_load_store_unit_with_thread ,uint32_t ,argv,x,_nb_thread);
620	SELFTEST2(_link_thread_and_functionnal_unit ,bool ,argv,x,_nb_thread,_nb_functionnal_unit);
621	SELFTEST1(_link_icache_port_with_thread ,uint32_t ,argv,x,_nb_thread);
622	SELFTEST2(_link_dcache_port_with_load_store_unit ,uint32_t ,argv,x,_nb_load_store_unit,_nb_cache_port[it1]);
623	SELFTEST0(_dispatch_priority ,Tpriority_t ,argv,x);
624	SELFTEST0(_dispatch_load_balancing ,Tload_balancing_t ,argv,x);
625
626	printf(" * End parameters\n");
627	printf("--------------------------------\n");
628
629	int _return = EXIT_SUCCESS;
630	try
631	{
632	morpheo::behavioural::core::Parameters * param = new morpheo::behavioural::core::Parameters
633	(
634	_size_general_data ,
635	_size_special_data ,
636	_get_custom_information ,
637
638	_nb_thread ,
639	_size_ifetch_queue ,
640	_nb_inst_fetch ,
641	_implement_group ,
642	_ras_size_queue ,
643	_upt_size_queue ,
644	_ufpt_size_queue ,
645
646	_nb_decod_bloc ,
647	_size_decod_queue ,
648	_decod_queue_scheme ,
649	_nb_inst_decod ,
650	_nb_context_select ,
651	_context_select_priority ,
652	_context_select_load_balancing ,
653
654	_nb_rename_bloc ,
655	_nb_inst_insert ,
656	_nb_inst_retire ,
657	_rename_select_priority ,
658	_rename_select_load_balancing ,
659	_rename_select_nb_front_end_select ,
660	_nb_general_register ,
661	_nb_special_register ,
662	_nb_reg_free ,
663	_nb_rename_unit_bank ,
664	// _size_read_counter ,
665
666	_nb_read_bloc ,
667	_size_read_queue ,
668	_size_reservation_station ,
669	_nb_inst_retire_reservation_station ,
670
671	_nb_write_bloc ,
672	_size_write_queue ,
673	_size_execute_queue ,
674	_nb_bypass_write ,
675	_write_queue_scheme ,
676
677	_nb_load_store_unit ,
678	_size_store_queue ,
679	_size_load_queue ,
680	_size_speculative_access_queue ,
681	_nb_port_check ,
682	_speculative_load ,
683	_nb_bypass_memory ,
684	_nb_cache_port ,
685	_nb_inst_memory ,
686
687	_nb_functionnal_unit ,
688	_nb_inst_functionnal_unit ,
689	_timing ,
690
691	_nb_icache_port ,
692	_icache_port_priority ,
693	_icache_port_load_balancing ,
694
695	_nb_dcache_port ,
696	_dcache_port_priority ,
697	_dcache_port_load_balancing ,
698
699	_nb_front_end ,
700	_nb_context ,
701	_nb_decod_unit ,
702	_nb_inst_branch_predict ,
703	_nb_inst_branch_decod ,
704	_nb_inst_branch_update ,
705	_btb_size_queue ,
706	_btb_associativity ,
707	_btb_size_counter ,
708	_btb_victim_scheme ,
709	_dir_predictor_scheme ,
710	_dir_have_bht ,
711	_dir_bht_size_shifter ,
712	_dir_bht_nb_shifter ,
713	_dir_have_pht ,
714	_dir_pht_size_counter ,
715	_dir_pht_nb_counter ,
716	_dir_pht_size_address_share ,
717	_dir_pht_scheme ,
718
719	_nb_ooo_engine ,
720	_nb_rename_unit ,
721	_nb_inst_issue ,
722	_nb_inst_reexecute ,
723	_nb_inst_commit ,
724	_nb_inst_branch_complete ,
725	_nb_rename_unit_select ,
726	_nb_execute_loop_select ,
727	_size_re_order_buffer ,
728	_nb_re_order_buffer_bank ,
729	_commit_priority ,
730	_commit_load_balancing ,
731	_size_issue_queue ,
732	_issue_queue_scheme ,
733	_nb_issue_queue_bank ,
734	_issue_priority ,
735	_issue_load_balancing ,
736	_size_reexecute_queue ,
737	_reexecute_priority ,
738	_reexecute_load_balancing ,
739
740	_nb_execute_loop ,
741	_nb_read_unit ,
742	_nb_execute_unit ,
743	_nb_write_unit ,
744	_nb_gpr_bank ,
745	_nb_gpr_port_read_by_bank ,
746	_nb_gpr_port_write_by_bank ,
747	_nb_spr_bank ,
748	_nb_spr_port_read_by_bank ,
749	_nb_spr_port_write_by_bank ,
750	_execution_unit_to_write_unit_priority ,
751	_read_unit_to_execution_unit_priority ,
752
753	_link_context_with_thread ,
754	_link_decod_unit_with_decod_bloc ,
755	_link_rename_unit_with_rename_bloc ,
756	_link_read_unit_with_read_bloc ,
757	_link_write_unit_with_write_bloc ,
758	_link_execute_unit_with_functionnal_unit ,
759	_link_execute_unit_with_load_store_unit ,
760	_link_decod_bloc_with_thread ,
761	_link_rename_bloc_with_front_end ,
762	_table_dispatch ,
763	_link_read_bloc_and_load_store_unit ,
764	_link_read_bloc_and_functionnal_unit ,
765	_link_write_bloc_and_load_store_unit ,
766	_link_write_bloc_and_functionnal_unit ,
767	_link_load_store_unit_with_thread ,
768	_link_thread_and_functionnal_unit ,
769	_link_icache_port_with_thread ,
770	_link_dcache_port_with_load_store_unit ,
771
772	_dispatch_priority ,
773	_dispatch_load_balancing ,
774	true // is_toplevel
775	);
776
777	test (name,param);
778	}
779	catch (morpheo::ErrorMorpheo & error)
780	{
781	msg (_("<%s> :\n%s"),name.c_str(), error.what ());
782	_return = EXIT_FAILURE;
783	}
784
785	try
786	{
787	if (_return == EXIT_SUCCESS)
788	TEST_OK("Core : no error");
789	else
790	TEST_KO("Core : a lot of error");
791	}
792	catch (morpheo::ErrorMorpheo & error)
793	{
794	// msg (_("<%s> :\n%s"),name.c_str(), error.what ());
795	_return = EXIT_FAILURE;
796	}
797
798	return (_return);
799	}

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

Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/SelfTest/src/main.cpp @ 146

Download in other formats: