Context Navigation

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

Last change on this file since 130 was 128, checked in by rosiere, 15 years ago
1) Correct bug in link two signal 2) Fix error detected with valgrind 3) modif distexe script
Property svn:keywords set to `Id`
File size: 21.5 KB

Line
1	/*
2	* $Id: main.cpp 128 2009-06-26 08:43:23Z rosiere $
3	*
4	* [ Description ]
5	*
6	*/
7
8	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/include/test.h"
9	#include "Behavioural/include/Allocation.h"
10
11	#define NB_PARAMS 18
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 (_(" * nb_read_unit (uint32_t )\n"));
18	err (_(" * nb_functionnal_unit (uint32_t )\n"));
19	err (_(" * nb_load_store_unit (uint32_t )\n"));
20	err (_(" * nb_write_unit (uint32_t )\n"));
21	err (_(" * nb_context (uint32_t )\n"));
22	err (_(" * nb_front_end (uint32_t )\n"));
23	err (_(" * nb_ooo_engine (uint32_t )\n"));
24	err (_(" * nb_packet (uint32_t )\n"));
25	err (_(" * size_general_data (uint32_t )\n"));
26	err (_(" * size_special_data (uint32_t )\n"));
27	err (_(" * size_read_queue [nb_read_unit] (uint32_t )\n"));
28	err (_(" * size_reservation_station [nb_read_unit] (uint32_t )\n"));
29	err (_(" * nb_inst_retire [nb_read_unit] (uint32_t )\n"));
30	err (_(" * nb_inst_functionnal_unit [nb_functionnal_unit] (uint32_t )\n"));
31	err (_(" * size_store_queue [nb_load_store_unit] (uint32_t )\n"));
32	err (_(" * size_load_queue [nb_load_store_unit] (uint32_t )\n"));
33	err (_(" * size_speculative_access_queue [nb_load_store_unit] (uint32_t )\n"));
34	err (_(" * nb_port_check [nb_load_store_unit] (uint32_t )\n"));
35	err (_(" * speculative_load [nb_load_store_unit] (Tspeculative_load_t)\n"));
36	err (_(" * nb_bypass_memory [nb_load_store_unit] (uint32_t )\n"));
37	err (_(" * nb_cache_port [nb_load_store_unit] (uint32_t )\n"));
38	err (_(" * nb_inst_memory [nb_load_store_unit] (uint32_t )\n"));
39	err (_(" * size_write_queue [nb_write_unit] (uint32_t )\n"));
40	err (_(" * size_execute_queue [nb_write_unit] (uint32_t )\n"));
41	err (_(" * nb_bypass_write [nb_write_unit] (uint32_t )\n"));
42	err (_(" * write_queue_scheme [nb_write_unit] (Twrite_queue_scheme_t)\n"));
43	err (_(" * nb_gpr_bank (uint32_t )\n"));
44	err (_(" * nb_gpr_port_read_by_bank (uint32_t )\n"));
45	err (_(" * nb_gpr_port_write_by_bank (uint32_t )\n"));
46	err (_(" * nb_spr_bank (uint32_t )\n"));
47	err (_(" * nb_spr_port_read_by_bank (uint32_t )\n"));
48	err (_(" * nb_spr_port_write_by_bank (uint32_t )\n"));
49	err (_(" * nb_general_register [nb_ooo_engine] (uint32_t )\n"));
50	err (_(" * nb_special_register [nb_ooo_engine] (uint32_t )\n"));
51	err (_(" * nb_inst_insert_rob [nb_ooo_engine] (uint32_t )\n"));
52	err (_(" * nb_inst_retire_rob [nb_ooo_engine] (uint32_t )\n"));
53	err (_(" * execution_unit_to_write_unit_priority (Tpriority_t )\n"));
54	err (_(" * execution_unit_to_write_unit_table_routing[nb_execute_unit][nb_execute_unit_port][nb_write_unit] (bool )\n"));
55	err (_(" * execution_unit_to_write_unit_table_thread [nb_write_unit][nb_thread] (bool )\n"));
56	err (_(" * read_unit_to_execution_unit_priority (Tpriority_t )\n"));
57	err (_(" * read_unit_to_execution_unit_table_routing [nb_read_unit][nb_execute_unit][nb_execute_unit_port] (bool )\n"));
58	err (_(" * read_unit_to_execution_unit_table_thread [nb_execute_unit][nb_thread] (bool )\n"));
59	err (_(" * is_load_store_unit [nb_execute_unit] (bool )\n"));
60	err (_(" * translate_num_execute_unit [nb_execute_unit] (uint32_t )\n"));
61
62
63	exit (1);
64	}
65
66	#ifndef SYSTEMC
67	int main (int argc, char * argv[])
68	#else
69	int sc_main (int argc, char * argv[])
70	#endif
71	{
72	// Command
73	for (int32_t i=0; i<argc; ++i)
74	msg("%s ",argv[i]);
75	msg("\n");
76
77	if (argc < 2+NB_PARAMS)
78	usage (argc, argv);
79
80	uint32_t x = 1;
81
82	string name = argv[x++];
83	uint32_t nb_read_unit = atoi(argv[x++]);
84	uint32_t nb_functionnal_unit = atoi(argv[x++]);
85	uint32_t nb_load_store_unit = atoi(argv[x++]);
86	uint32_t nb_write_unit = atoi(argv[x++]);
87	uint32_t nb_context = atoi(argv[x++]);
88	uint32_t nb_front_end = atoi(argv[x++]);
89	uint32_t nb_ooo_engine = atoi(argv[x++]);
90	uint32_t nb_packet = atoi(argv[x++]);
91	uint32_t size_general_data = atoi(argv[x++]);
92	uint32_t size_special_data = atoi(argv[x++]);
93
94	uint32_t nb_execute_unit = nb_functionnal_unit + nb_load_store_unit;
95	uint32_t nb_thread = get_nb_thread(nb_context, nb_front_end, nb_ooo_engine);
96
97	int32_t nb_params = (2+NB_PARAMS+
98	3*nb_read_unit+
99	1*nb_functionnal_unit+
100	8*nb_load_store_unit+
101	4*nb_write_unit+
102	4*nb_ooo_engine+
103	// sum_execute_unit_port*nb_write_unit+
104	nb_write_unit*nb_thread+
105	// nb_read_unit*sum_execute_unit_port+
106	nb_execute_unit*nb_thread+
107	2*nb_execute_unit);
108
109	if (argc <= nb_params)
110	usage (argc, argv);
111
112	uint32_t * size_read_queue = new uint32_t [nb_read_unit];
113	for (uint32_t i=0; i<nb_read_unit; i++)
114	size_read_queue [i] = atoi(argv[x++]);
115
116	uint32_t * size_reservation_station = new uint32_t [nb_read_unit];
117	for (uint32_t i=0; i<nb_read_unit; i++)
118	size_reservation_station [i] = atoi(argv[x++]);
119
120	uint32_t * nb_inst_retire = new uint32_t [nb_read_unit];
121	for (uint32_t i=0; i<nb_read_unit; i++)
122	nb_inst_retire [i] = atoi(argv[x++]);
123
124	uint32_t * nb_inst_functionnal_unit = new uint32_t [nb_functionnal_unit];
125	for (uint32_t i=0; i<nb_functionnal_unit; i++)
126	nb_inst_functionnal_unit [i] = atoi(argv[x++]);
127
128	uint32_t * size_store_queue = new uint32_t [nb_load_store_unit];
129	for (uint32_t i=0; i<nb_load_store_unit; i++)
130	size_store_queue [i] = atoi(argv[x++]);
131
132	uint32_t * size_load_queue = new uint32_t [nb_load_store_unit];
133	for (uint32_t i=0; i<nb_load_store_unit; i++)
134	size_load_queue [i] = atoi(argv[x++]);
135
136	uint32_t * size_speculative_access_queue = new uint32_t [nb_load_store_unit];
137	for (uint32_t i=0; i<nb_load_store_unit; i++)
138	size_speculative_access_queue [i] = atoi(argv[x++]);
139
140	uint32_t * nb_port_check = new uint32_t [nb_load_store_unit];
141	for (uint32_t i=0; i<nb_load_store_unit; i++)
142	nb_port_check [i] = atoi(argv[x++]);
143
144	Tspeculative_load_t * speculative_load = new Tspeculative_load_t [nb_load_store_unit];
145	for (uint32_t i=0; i<nb_load_store_unit; i++)
146	speculative_load [i] = fromString<Tspeculative_load_t>(argv[x++]);
147
148	uint32_t * nb_bypass_memory = new uint32_t [nb_load_store_unit];
149	for (uint32_t i=0; i<nb_load_store_unit; i++)
150	nb_bypass_memory [i] = atoi(argv[x++]);
151
152	uint32_t * nb_cache_port = new uint32_t [nb_load_store_unit];
153	for (uint32_t i=0; i<nb_load_store_unit; i++)
154	nb_cache_port [i] = atoi(argv[x++]);
155
156	uint32_t * nb_inst_memory = new uint32_t [nb_load_store_unit];
157	for (uint32_t i=0; i<nb_load_store_unit; i++)
158	nb_inst_memory [i] = atoi(argv[x++]);
159
160
161	uint32_t sum_execute_unit_port = 0;
162	for (uint32_t i=0; i<nb_load_store_unit; i++)
163	sum_execute_unit_port += nb_inst_memory[i];
164	for (uint32_t i=0; i<nb_functionnal_unit; i++)
165	sum_execute_unit_port += nb_inst_functionnal_unit[i];
166
167	nb_params = (2+NB_PARAMS+
168	3*nb_read_unit+
169	1*nb_functionnal_unit+
170	8*nb_load_store_unit+
171	4*nb_write_unit+
172	4*nb_ooo_engine+
173	sum_execute_unit_port*nb_write_unit+
174	nb_write_unit*nb_thread+
175	nb_read_unit*sum_execute_unit_port+
176	nb_execute_unit*nb_thread+
177	2*nb_execute_unit);
178
179	if (argc != nb_params)
180	{
181	msg("nb_functionnal_unit : %d\n",nb_functionnal_unit);
182	msg("nb_load_store_unit : %d\n",nb_load_store_unit );
183	msg("sum_execute_unit_port : %d.\n",sum_execute_unit_port);
184	msg(_("Have %d parameters.\n"),argc );
185	msg(_("Need %d parameters.\n"),nb_params);
186	usage (argc, argv);
187	}
188
189	uint32_t * size_write_queue = new uint32_t [nb_write_unit];
190	for (uint32_t i=0; i<nb_write_unit; i++)
191	size_write_queue [i] = atoi(argv[x++]);
192
193	uint32_t * size_execute_queue = new uint32_t [nb_write_unit];
194	for (uint32_t i=0; i<nb_write_unit; i++)
195	size_execute_queue [i] = atoi(argv[x++]);
196
197	uint32_t * nb_bypass_write = new uint32_t [nb_write_unit];
198	for (uint32_t i=0; i<nb_write_unit; i++)
199	nb_bypass_write [i] = atoi(argv[x++]);
200
201	multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t * write_queue_scheme = new multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t [nb_write_unit];
202	for (uint32_t i=0; i<nb_write_unit; i++)
203	write_queue_scheme [i] = fromString<multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t>(argv[x++]);
204
205	uint32_t nb_gpr_bank = atoi(argv[x++]);
206	uint32_t nb_gpr_port_read_by_bank = atoi(argv[x++]);
207	uint32_t nb_gpr_port_write_by_bank = atoi(argv[x++]);
208	uint32_t nb_spr_bank = atoi(argv[x++]);
209	uint32_t nb_spr_port_read_by_bank = atoi(argv[x++]);
210	uint32_t nb_spr_port_write_by_bank = atoi(argv[x++]);
211
212	uint32_t * nb_general_register = new uint32_t [nb_ooo_engine];
213	for (uint32_t i=0; i<nb_ooo_engine; i++)
214	nb_general_register [i] = atoi(argv[x++]);
215
216	uint32_t * nb_special_register = new uint32_t [nb_ooo_engine];
217	for (uint32_t i=0; i<nb_ooo_engine; i++)
218	nb_special_register [i] = atoi(argv[x++]);
219
220	uint32_t * nb_inst_insert_rob = new uint32_t [nb_ooo_engine];
221	for (uint32_t i=0; i<nb_ooo_engine; i++)
222	nb_inst_insert_rob [i] = atoi(argv[x++]);
223
224	uint32_t * nb_inst_retire_rob = new uint32_t [nb_ooo_engine];
225	for (uint32_t i=0; i<nb_ooo_engine; i++)
226	nb_inst_retire_rob [i] = atoi(argv[x++]);
227
228	Tpriority_t execution_unit_to_write_unit_priority = fromString<Tpriority_t>(argv[x++]);
229
230	bool * execution_unit_to_write_unit_table_routing = new bool [nb_execute_unit];
231	for (uint32_t i=0; i<nb_execute_unit; i++)
232	{
233	uint32_t nb_execute_unit_port = (i<nb_load_store_unit)?nb_inst_memory[i]:nb_inst_functionnal_unit[i-nb_load_store_unit];
234
235	execution_unit_to_write_unit_table_routing [i] = new bool * [nb_execute_unit_port];
236
237	for (uint32_t j=0; j<nb_execute_unit_port; j++)
238	{
239	execution_unit_to_write_unit_table_routing [i][j] = new bool [nb_write_unit];
240
241	for (uint32_t k=0; k<nb_write_unit; k++)
242	execution_unit_to_write_unit_table_routing [i][j][k] = atoi(argv[x++]);
243	}
244	}
245
246	bool ** execution_unit_to_write_unit_table_thread = new bool * [nb_write_unit];
247	for (uint32_t i=0; i<nb_write_unit; i++)
248	{
249	execution_unit_to_write_unit_table_thread [i] = new bool [nb_thread];
250	for (uint32_t j=0; j<nb_thread; j++)
251	execution_unit_to_write_unit_table_thread [i][j] = atoi(argv[x++]);
252	}
253	Tpriority_t read_unit_to_execution_unit_priority = fromString<Tpriority_t>(argv[x++]);
254
255	bool * read_unit_to_execution_unit_table_routing = new bool [nb_read_unit];
256	for (uint32_t i=0; i<nb_read_unit; i++)
257	{
258	read_unit_to_execution_unit_table_routing [i] = new bool * [nb_execute_unit];
259	for (uint32_t j=0; j<nb_execute_unit; j++)
260	{
261	uint32_t nb_execute_unit_port = (j<nb_load_store_unit)?nb_inst_memory[j]:nb_inst_functionnal_unit[j-nb_load_store_unit];
262	read_unit_to_execution_unit_table_routing [i][j] = new bool [nb_execute_unit_port];
263
264	for (uint32_t k=0; k<nb_execute_unit_port; k++)
265	read_unit_to_execution_unit_table_routing [i][j][k] = atoi(argv[x++]);
266	}
267	}
268
269	bool ** read_unit_to_execution_unit_table_thread = new bool * [nb_execute_unit];
270	for (uint32_t i=0; i<nb_execute_unit; i++)
271	{
272	read_unit_to_execution_unit_table_thread [i] = new bool [nb_thread];
273	for (uint32_t j=0; j<nb_thread; j++)
274	read_unit_to_execution_unit_table_thread [i][j] = atoi(argv[x++]);
275	}
276
277	bool * is_load_store_unit = new bool [nb_execute_unit];
278	for (uint32_t i=0; i<nb_execute_unit; i++)
279	is_load_store_unit [i] = fromString<bool>(argv[x++]);
280
281	uint32_t * translate_num_execute_unit = new uint32_t [nb_execute_unit];
282	for (uint32_t i=0; i<nb_execute_unit; i++)
283	translate_num_execute_unit [i] = fromString<uint32_t>(argv[x++]);
284
285	execute_timing_t * timing = new execute_timing_t [nb_functionnal_unit];
286	// alloc and reset timing array
287	for (uint32_t i=0; i< nb_functionnal_unit; i++)
288	{
289	timing [i] = new execute_timing_t * [MAX_TYPE];
290
291	for (uint32_t j=0; j< MAX_TYPE; j++)
292	{
293	timing [i][j]= new execute_timing_t [MAX_OPERATION];
294
295	for (uint32_t k=0; k< MAX_OPERATION; k++)
296	timing[i][j][k]._delay = timing[i][j][k]._latence = 0;
297	}
298	}
299
300	for (uint32_t i=0; i< nb_functionnal_unit; i++)
301	for (uint32_t j=0; j< MAX_TYPE; j++)
302	{
303	if ( (j != TYPE_MEMORY) and
304	not ((i!=0) and ((j == TYPE_SPECIAL) or
305	(j == TYPE_CUSTOM))))
306	for (uint32_t k=0; k< MAX_OPERATION; k++)
307	timing[i][j][k]._delay = timing[i][j][k]._latence = 1;
308	}
309
310	morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void) = &(morpheo::behavioural::custom::default_get_custom_information);
311
312	bool * num_thread_valid;
313	ALLOC1(num_thread_valid ,bool, nb_thread);
314	for (uint32_t i=0; i<nb_thread; ++i)
315	num_thread_valid [i] = true;
316
317	try
318	{
319	morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters
320	(nb_read_unit ,
321	nb_functionnal_unit ,
322	nb_load_store_unit ,
323	nb_write_unit ,
324
325	nb_context ,
326	nb_front_end ,
327	nb_ooo_engine ,
328	nb_packet ,
329	size_general_data ,
330	size_special_data ,
331
332	size_read_queue ,
333	size_reservation_station ,
334	nb_inst_retire ,
335
336	nb_inst_functionnal_unit ,
337	timing ,
338	get_custom_information ,
339
340	size_store_queue ,
341	size_load_queue ,
342	size_speculative_access_queue ,
343	nb_port_check ,
344	speculative_load ,
345	nb_bypass_memory ,
346	nb_cache_port ,
347	nb_inst_memory ,
348
349	size_write_queue ,
350	size_execute_queue ,
351	nb_bypass_write ,
352	write_queue_scheme ,
353
354	nb_gpr_bank ,
355	nb_gpr_port_read_by_bank ,
356	nb_gpr_port_write_by_bank ,
357	nb_spr_bank ,
358	nb_spr_port_read_by_bank ,
359	nb_spr_port_write_by_bank ,
360	nb_general_register ,
361	nb_special_register ,
362	nb_inst_insert_rob ,
363	nb_inst_retire_rob ,
364
365	execution_unit_to_write_unit_priority ,
366	execution_unit_to_write_unit_table_routing ,
367	execution_unit_to_write_unit_table_thread ,
368
369	read_unit_to_execution_unit_priority ,
370	read_unit_to_execution_unit_table_routing ,
371	read_unit_to_execution_unit_table_thread ,
372
373	is_load_store_unit , //[nb_execute_unit]
374	translate_num_execute_unit , //[nb_execute_unit]
375	num_thread_valid , //[nb_thread]
376	true // is_toplevel
377	);
378
379	test (name,param);
380
381	delete param;
382	}
383	catch (morpheo::ErrorMorpheo & error)
384	{
385	msg (_("%s\n"),error.what ());
386	exit (EXIT_FAILURE);
387	}
388	catch (...)
389	{
390	err (_("This test must generate a error.\n"));
391	exit (EXIT_FAILURE);
392	}
393
394	for (uint32_t i=0; i< nb_functionnal_unit; i++)
395	{
396	for (uint32_t j=0; j< MAX_TYPE; j++)
397	delete [] timing [i][j];
398	delete [] timing [i];
399	}
400	delete [] timing;
401
402	DELETE1(translate_num_execute_unit ,_nb_execute_unit);
403	DELETE1(is_load_store_unit ,_nb_execute_unit);
404
405	for (uint32_t i=0; i<nb_execute_unit; i++)
406	delete read_unit_to_execution_unit_table_thread [i];
407	delete [] read_unit_to_execution_unit_table_thread;
408
409	for (uint32_t i=0; i<nb_read_unit; i++)
410	{
411	for (uint32_t j=0; j<nb_execute_unit; j++)
412	delete [] read_unit_to_execution_unit_table_routing [i][j];
413	delete [] read_unit_to_execution_unit_table_routing [i];
414	}
415	delete [] read_unit_to_execution_unit_table_routing;
416
417	for (uint32_t i=0; i<nb_write_unit; i++)
418	delete execution_unit_to_write_unit_table_thread [i];
419	delete [] execution_unit_to_write_unit_table_thread;
420
421	for (uint32_t i=0; i<nb_execute_unit; i++)
422	{
423	uint32_t nb_execute_unit_port = (i<nb_load_store_unit)?nb_inst_memory[i]:nb_inst_functionnal_unit[i-nb_load_store_unit];
424	for (uint32_t j=0; j<nb_execute_unit_port; j++)
425	delete [] execution_unit_to_write_unit_table_routing [i][j];
426	delete [] execution_unit_to_write_unit_table_routing [i];
427	}
428	delete [] execution_unit_to_write_unit_table_routing;
429
430	DELETE1(nb_inst_retire_rob ,_nb_ooo_engine);
431	DELETE1(nb_inst_insert_rob ,_nb_ooo_engine);
432	DELETE1(nb_special_register ,_nb_ooo_engine);
433	DELETE1(nb_general_register ,_nb_ooo_engine);
434	DELETE1(write_queue_scheme ,_nb_write_unit);
435	DELETE1(nb_bypass_write ,_nb_write_unit);
436	DELETE1(size_execute_queue ,_nb_write_unit);
437	DELETE1(size_write_queue ,_nb_write_unit);
438	DELETE1(nb_inst_memory ,_nb_load_store_unit);
439	DELETE1(nb_cache_port ,_nb_load_store_unit);
440	DELETE1(nb_bypass_memory ,_nb_load_store_unit);
441	DELETE1(speculative_load ,_nb_load_store_unit);
442	DELETE1(nb_port_check ,_nb_load_store_unit);
443	DELETE1(size_speculative_access_queue ,_nb_load_store_unit);
444	DELETE1(size_load_queue ,_nb_load_store_unit);
445	DELETE1(size_store_queue ,_nb_load_store_unit);
446	DELETE1(nb_inst_functionnal_unit ,_nb_functionnal_unit);
447	DELETE1(nb_inst_retire ,_nb_read_unit);
448	DELETE1(size_reservation_station ,_nb_read_unit);
449	DELETE1(size_read_queue ,_nb_read_unit);
450	DELETE1(num_thread_valid , nb_thread);
451
452	return (EXIT_SUCCESS);
453	}
454

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

Download in other formats: