Context Navigation

main.cpp @ 78

Last change on this file since 78 was 78, checked in by rosiere, 16 years ago

Add :

Execute_loop (must be test systemC)
Prediction
- Direction : predifined scheme
- Branch Target Buffer
iFetch_unit
- ifetch_queue
- pc management
Decod_unit
- coming soon : support for custom operation
Rename_unit
- RAT
- Free_list
- Dependence RAW check
- Load store unit pointer
New Environnement (hierarchy_memory will remove in a next version)

Modif :

Manage Custom Operation
All component in execute_loop to use the new statistics management

Not Finish :

Return Address Stack
Environnement

File size: 14.1 KB

Line
1	/*
2	* $Id$
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 [read_unit] (uint32_t )\n"));
27	err (_(" * size_reservation_station [read_unit] (uint32_t )\n"));
28	err (_(" * nb_inst_retire [read_unit] (uint32_t )\n"));
29	err (_(" * size_store_queue [load_store_unit] (uint32_t )\n"));
30	err (_(" * size_load_queue [load_store_unit] (uint32_t )\n"));
31	err (_(" * size_speculative_access_queue [load_store_unit] (uint32_t )\n"));
32	err (_(" * nb_port_check [load_store_unit] (uint32_t )\n"));
33	err (_(" * speculative_load [load_store_unit] (Tspeculative_load_t)\n"));
34	err (_(" * nb_bypass_memory [load_store_unit] (uint32_t )\n"));
35	err (_(" * size_write_queue [write_unit] (uint32_t )\n"));
36	err (_(" * size_execute_queue [write_unit] (uint32_t )\n"));
37	err (_(" * nb_bypass_write [write_unit] (uint32_t )\n"));
38	err (_(" * nb_gpr_bank (uint32_t )\n"));
39	err (_(" * nb_gpr_port_read_by_bank (uint32_t )\n"));
40	err (_(" * nb_gpr_port_write_by_bank (uint32_t )\n"));
41	err (_(" * nb_spr_bank (uint32_t )\n"));
42	err (_(" * nb_spr_port_read_by_bank (uint32_t )\n"));
43	err (_(" * nb_spr_port_write_by_bank (uint32_t )\n"));
44	err (_(" * nb_general_register [nb_ooo_engine] (uint32_t )\n"));
45	err (_(" * nb_special_register [nb_ooo_engine] (uint32_t )\n"));
46	err (_(" * nb_inst_insert_rob [nb_ooo_engine] (uint32_t )\n"));
47	err (_(" * nb_inst_retire_rob [nb_ooo_engine] (uint32_t )\n"));
48	err (_(" * execution_unit_to_write_unit_priority (Tpriority_t )\n"));
49	err (_(" * execution_unit_to_write_unit_table_routing[nb_execute_unit][nb_write_unit] (bool )\n"));
50	err (_(" * execution_unit_to_write_unit_table_thread [nb_write_unit][nb_thread] (bool )\n"));
51	err (_(" * read_unit_to_execution_unit_priority (Tpriority_t )\n"));
52	err (_(" * read_unit_to_execution_unit_table_routing [nb_read_unit][nb_execute_unit] (bool )\n"));
53	err (_(" * read_unit_to_execution_unit_table_thread [nb_execute_unit][nb_thread] (bool )\n"));
54
55	exit (1);
56	}
57
58	#ifndef SYSTEMC
59	int main (int argc, char * argv[])
60	#else
61	int sc_main (int argc, char * argv[])
62	#endif
63	{
64	if (argc < 2+NB_PARAMS)
65	usage (argc, argv);
66
67	uint32_t x = 1;
68
69	string name = argv[x++];
70	uint32_t nb_read_unit = atoi(argv[x++]);
71	uint32_t nb_functionnal_unit = atoi(argv[x++]);
72	uint32_t nb_load_store_unit = atoi(argv[x++]);
73	uint32_t nb_write_unit = atoi(argv[x++]);
74	uint32_t nb_context = atoi(argv[x++]);
75	uint32_t nb_front_end = atoi(argv[x++]);
76	uint32_t nb_ooo_engine = atoi(argv[x++]);
77	uint32_t nb_packet = atoi(argv[x++]);
78	uint32_t size_general_data = atoi(argv[x++]);
79	uint32_t size_special_data = atoi(argv[x++]);
80
81	uint32_t nb_execute_unit = nb_functionnal_unit + nb_load_store_unit;
82	uint32_t nb_thread = get_nb_thread(nb_context, nb_front_end, nb_ooo_engine);
83
84	int32_t nb_params = (2+NB_PARAMS+
85	3*nb_read_unit+
86	6*nb_load_store_unit+
87	3*nb_write_unit+
88	4*nb_ooo_engine+
89	nb_execute_unit*nb_write_unit+
90	nb_write_unit*nb_thread+
91	nb_read_unit*nb_execute_unit+
92	nb_execute_unit*nb_thread);
93
94
95
96	if (argc != nb_params)
97	{
98	msg(_("Need %d parameters."),nb_params);
99	usage (argc, argv);
100	}
101	uint32_t * size_read_queue = new uint32_t [nb_read_unit];
102	for (uint32_t i=0; i<nb_read_unit; i++)
103	size_read_queue [i] = atoi(argv[x++]);
104
105	uint32_t * size_reservation_station = new uint32_t [nb_read_unit];
106	for (uint32_t i=0; i<nb_read_unit; i++)
107	size_reservation_station [i] = atoi(argv[x++]);
108
109	uint32_t * nb_inst_retire = new uint32_t [nb_read_unit];
110	for (uint32_t i=0; i<nb_read_unit; i++)
111	nb_inst_retire [i] = atoi(argv[x++]);
112
113	uint32_t * size_store_queue = new uint32_t [nb_load_store_unit];
114	for (uint32_t i=0; i<nb_load_store_unit; i++)
115	size_store_queue [i] = atoi(argv[x++]);
116
117	uint32_t * size_load_queue = new uint32_t [nb_load_store_unit];
118	for (uint32_t i=0; i<nb_load_store_unit; i++)
119	size_load_queue [i] = atoi(argv[x++]);
120
121	uint32_t * size_speculative_access_queue = new uint32_t [nb_load_store_unit];
122	for (uint32_t i=0; i<nb_load_store_unit; i++)
123	size_speculative_access_queue [i] = atoi(argv[x++]);
124
125	uint32_t * nb_port_check = new uint32_t [nb_load_store_unit];
126	for (uint32_t i=0; i<nb_load_store_unit; i++)
127	nb_port_check [i] = atoi(argv[x++]);
128
129	Tspeculative_load_t * speculative_load = new Tspeculative_load_t [nb_load_store_unit];
130	for (uint32_t i=0; i<nb_load_store_unit; i++)
131	speculative_load [i] = fromString<Tspeculative_load_t>(argv[x++]);
132
133	uint32_t * nb_bypass_memory = new uint32_t [nb_load_store_unit];
134	for (uint32_t i=0; i<nb_load_store_unit; i++)
135	nb_bypass_memory [i] = atoi(argv[x++]);
136
137	uint32_t * size_write_queue = new uint32_t [nb_write_unit];
138	for (uint32_t i=0; i<nb_write_unit; i++)
139	size_write_queue [i] = atoi(argv[x++]);
140
141	uint32_t * size_execute_queue = new uint32_t [nb_write_unit];
142	for (uint32_t i=0; i<nb_write_unit; i++)
143	size_execute_queue [i] = atoi(argv[x++]);
144
145	uint32_t * nb_bypass_write = new uint32_t [nb_write_unit];
146	for (uint32_t i=0; i<nb_write_unit; i++)
147	nb_bypass_write [i] = atoi(argv[x++]);
148
149	uint32_t nb_gpr_bank = atoi(argv[x++]);
150	uint32_t nb_gpr_port_read_by_bank = atoi(argv[x++]);
151	uint32_t nb_gpr_port_write_by_bank = atoi(argv[x++]);
152	uint32_t nb_spr_bank = atoi(argv[x++]);
153	uint32_t nb_spr_port_read_by_bank = atoi(argv[x++]);
154	uint32_t nb_spr_port_write_by_bank = atoi(argv[x++]);
155
156	uint32_t * nb_general_register = new uint32_t [nb_ooo_engine];
157	for (uint32_t i=0; i<nb_ooo_engine; i++)
158	nb_general_register [i] = atoi(argv[x++]);
159
160	uint32_t * nb_special_register = new uint32_t [nb_ooo_engine];
161	for (uint32_t i=0; i<nb_ooo_engine; i++)
162	nb_special_register [i] = atoi(argv[x++]);
163
164	uint32_t * nb_inst_insert_rob = new uint32_t [nb_ooo_engine];
165	for (uint32_t i=0; i<nb_ooo_engine; i++)
166	nb_inst_insert_rob [i] = atoi(argv[x++]);
167
168	uint32_t * nb_inst_retire_rob = new uint32_t [nb_ooo_engine];
169	for (uint32_t i=0; i<nb_ooo_engine; i++)
170	nb_inst_retire_rob [i] = atoi(argv[x++]);
171
172	Tpriority_t execution_unit_to_write_unit_priority = fromString<Tpriority_t>(argv[x++]);
173
174	bool ** execution_unit_to_write_unit_table_routing = new bool * [nb_execute_unit];
175	for (uint32_t i=0; i<nb_execute_unit; i++)
176	{
177	execution_unit_to_write_unit_table_routing [i] = new bool [nb_write_unit];
178	for (uint32_t j=0; j<nb_write_unit; j++)
179	execution_unit_to_write_unit_table_routing [i][j] = atoi(argv[x++]);
180	}
181	bool ** execution_unit_to_write_unit_table_thread = new bool * [nb_write_unit];
182	for (uint32_t i=0; i<nb_write_unit; i++)
183	{
184	execution_unit_to_write_unit_table_thread [i] = new bool [nb_thread];
185	for (uint32_t j=0; j<nb_thread; j++)
186	execution_unit_to_write_unit_table_thread [i][j] = atoi(argv[x++]);
187	}
188	Tpriority_t read_unit_to_execution_unit_priority = fromString<Tpriority_t>(argv[x++]);
189
190	bool ** read_unit_to_execution_unit_table_routing = new bool * [nb_read_unit];
191	for (uint32_t i=0; i<nb_read_unit; i++)
192	{
193	read_unit_to_execution_unit_table_routing [i] = new bool [nb_execute_unit];
194	for (uint32_t j=0; j<nb_execute_unit; j++)
195	read_unit_to_execution_unit_table_routing [i][j] = atoi(argv[x++]);
196	}
197	bool ** read_unit_to_execution_unit_table_thread = new bool * [nb_execute_unit];
198	for (uint32_t i=0; i<nb_execute_unit; i++)
199	{
200	read_unit_to_execution_unit_table_thread [i] = new bool [nb_thread];
201	for (uint32_t j=0; j<nb_thread; j++)
202	read_unit_to_execution_unit_table_thread [i][j] = atoi(argv[x++]);
203	}
204	execute_timing_t * timing = new execute_timing_t [nb_execute_unit];
205
206	// alloc and reset timing array
207	for (uint32_t i=0; i< nb_execute_unit; i++)
208	{
209	timing [i] = new execute_timing_t * [MAX_TYPE];
210
211	for (uint32_t j=0; j< MAX_TYPE; j++)
212	{
213	timing [i][j]= new execute_timing_t [MAX_OPERATION];
214
215	for (uint32_t k=0; k< MAX_OPERATION; k++)
216	timing[i][j][k]._delay = timing[i][j][k]._latence = 0;
217	}
218	}
219
220	for (uint32_t i=0; i< nb_load_store_unit; i++)
221	for (uint32_t k=0; k< MAX_OPERATION; k++)
222	timing[i][TYPE_MEMORY][k]._delay = timing[i][TYPE_MEMORY][k]._latence = 1;
223	for (uint32_t i=0; i< nb_functionnal_unit; i++)
224	for (uint32_t j=0; j< MAX_TYPE; j++)
225	if (j != TYPE_MEMORY)
226	for (uint32_t k=0; k< MAX_OPERATION; k++)
227	timing[i+nb_load_store_unit][j][k]._delay = timing[i+nb_load_store_unit][j][k]._latence = 1;
228
229	morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t) = &(morpheo::behavioural::custom::default_get_custom_information);
230
231	try
232	{
233	morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters
234	(nb_read_unit ,
235	nb_functionnal_unit ,
236	nb_load_store_unit ,
237	nb_write_unit ,
238
239	nb_context ,
240	nb_front_end ,
241	nb_ooo_engine ,
242	nb_packet ,
243	size_general_data ,
244	size_special_data ,
245
246	size_read_queue ,
247	size_reservation_station ,
248	nb_inst_retire ,
249
250	timing ,
251	get_custom_information ,
252
253	size_store_queue ,
254	size_load_queue ,
255	size_speculative_access_queue ,
256	nb_port_check ,
257	speculative_load ,
258
259	nb_bypass_memory ,
260	size_write_queue ,
261	size_execute_queue ,
262	nb_bypass_write ,
263
264	nb_gpr_bank ,
265	nb_gpr_port_read_by_bank ,
266	nb_gpr_port_write_by_bank ,
267	nb_spr_bank ,
268	nb_spr_port_read_by_bank ,
269	nb_spr_port_write_by_bank ,
270	nb_general_register ,
271	nb_special_register ,
272	nb_inst_insert_rob ,
273	nb_inst_retire_rob ,
274
275	execution_unit_to_write_unit_priority ,
276	execution_unit_to_write_unit_table_routing ,
277	execution_unit_to_write_unit_table_thread ,
278
279	read_unit_to_execution_unit_priority ,
280	read_unit_to_execution_unit_table_routing ,
281	read_unit_to_execution_unit_table_thread );
282
283	msg(_("%s"),param->print(1).c_str());
284
285	test (name,param);
286	}
287	catch (morpheo::ErrorMorpheo & error)
288	{
289	msg (_("<%s> : %s.\n"),name.c_str(), error.what ());
290	exit (EXIT_FAILURE);
291	}
292	catch (...)
293	{
294	err (_("<%s> : This test must generate a error.\n"),name.c_str());
295	exit (EXIT_FAILURE);
296	}
297
298	return (EXIT_SUCCESS);
299	}
300

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

Context Navigation

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

Download in other formats: