Context Navigation

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

Last change on this file since 97 was 97, checked in by rosiere, 16 years ago
1) Update Prediction Table : statistics 2) Size instruction address on 30 bits 3) Change Log File 4) Add debug_level in simulation configuration file
Property svn:keywords set to `Id`
File size: 52.6 KB

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

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

Download in other formats: