Context Navigation

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

Last change on this file since 115 was 115, checked in by rosiere, 15 years ago
1) Write queue with mealy 2) Network : fix bug 3) leak memory
Property svn:keywords set to `Id`
File size: 18.8 KB

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

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

Download in other formats: