Context Navigation

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

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

Download in other formats: