Context Navigation

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

Last change on this file since 88 was 88, checked in by rosiere, 16 years ago
Almost complete design with Test and test platform
Property svn:keywords set to `Id`
File size: 52.2 KB

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

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

Download in other formats: