Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters.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: 29.3 KB

Line
1	/*
2	* $Id: Parameters.cpp 115 2009-04-20 21:29:17Z rosiere $
3	*
4	* [ Description ]
5	*
6	*/
7
8	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/include/Parameters.h"
9	#include "Common/include/Max.h"
10
11	namespace morpheo {
12	namespace behavioural {
13	namespace core {
14	namespace multi_execute_loop {
15	namespace execute_loop {
16
17
18	#undef FUNCTION
19	#define FUNCTION "Execute_loop::Parameters"
20	Parameters::Parameters (uint32_t nb_read_unit ,
21	uint32_t nb_functionnal_unit ,
22	uint32_t nb_load_store_unit ,
23	uint32_t nb_write_unit ,
24
25	uint32_t nb_context ,
26	uint32_t nb_front_end ,
27	uint32_t nb_ooo_engine ,
28	uint32_t nb_packet ,
29	uint32_t size_general_data ,
30	uint32_t size_special_data ,
31
32	uint32_t * size_read_queue ,//[nb_read_unit]
33	uint32_t * size_reservation_station ,//[nb_read_unit]
34	uint32_t * nb_inst_retire ,//[nb_read_unit]
35
36	uint32_t * nb_inst_functionnal_unit ,//[nb_functionnal_unit]
37	execute_timing_t *** timing ,//[nb_functionnal_unit][nb_type][nb_operation]
38	morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
39
40	uint32_t * size_store_queue ,//[nb_load_store_unit]
41	uint32_t * size_load_queue ,//[nb_load_store_unit]
42	uint32_t * size_speculative_access_queue ,//[nb_load_store_unit]
43	uint32_t * nb_port_check ,//[nb_load_store_unit]
44	Tspeculative_load_t * speculative_load ,//[nb_load_store_unit]
45	uint32_t * nb_bypass_memory ,//[nb_load_store_unit]
46	uint32_t * nb_cache_port ,//[nb_load_store_unit]
47	uint32_t * nb_inst_memory ,//[nb_load_store_unit]
48
49	uint32_t * size_write_queue ,//[nb_write_unit]
50	uint32_t * size_execute_queue ,//[nb_write_unit]
51	uint32_t * nb_bypass_write ,//[nb_write_unit]
52	multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t * write_queue_scheme,//[nb_write_unit]
53
54	uint32_t nb_gpr_bank ,
55	uint32_t nb_gpr_port_read_by_bank ,
56	uint32_t nb_gpr_port_write_by_bank ,
57	uint32_t nb_spr_bank ,
58	uint32_t nb_spr_port_read_by_bank ,
59	uint32_t nb_spr_port_write_by_bank ,
60	uint32_t * nb_general_register ,//[nb_ooo_engine]
61	uint32_t * nb_special_register ,//[nb_ooo_engine]
62	uint32_t * nb_inst_insert_rob ,//[nb_ooo_engine]
63	uint32_t * nb_inst_retire_rob ,//[nb_ooo_engine]
64
65	Tpriority_t execution_unit_to_write_unit_priority ,
66	bool *** execution_unit_to_write_unit_table_routing,//[nb_execute_unit][nb_execute_unit_port][nb_write_unit]
67	bool ** execution_unit_to_write_unit_table_thread ,//[nb_write_unit][nb_thread]
68
69	Tpriority_t read_unit_to_execution_unit_priority ,
70	bool *** read_unit_to_execution_unit_table_routing ,//[nb_read_unit][nb_execute_unit][nb_execute_unit_port]
71	bool ** read_unit_to_execution_unit_table_thread ,//[nb_execute_unit][nb_thread]
72
73	bool * is_load_store_unit ,//[nb_execute_unit]
74	uint32_t * translate_num_execute_unit ,//[nb_execute_unit]
75
76	bool is_toplevel
77	)
78	{
79	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
80
81	_nb_read_unit = nb_read_unit ;
82	_nb_functionnal_unit = nb_functionnal_unit ;
83	_nb_load_store_unit = nb_load_store_unit ;
84	_nb_write_unit = nb_write_unit ;
85
86	_nb_context = nb_context ;
87	_nb_front_end = nb_front_end ;
88	_nb_ooo_engine = nb_ooo_engine ;
89	_nb_packet = nb_packet ;
90
91	_size_read_queue = size_read_queue ;
92	_size_reservation_station = size_reservation_station ;
93	_nb_inst_retire = nb_inst_retire ;
94
95	_nb_inst_functionnal_unit = nb_inst_functionnal_unit ;
96	_timing = timing ;
97	_get_custom_information = get_custom_information ;
98
99	_size_store_queue = size_store_queue ;
100	_size_load_queue = size_load_queue ;
101	_size_speculative_access_queue = size_speculative_access_queue ;
102	_nb_port_check = nb_port_check ;
103	_speculative_load = speculative_load ;
104	_nb_bypass_memory = nb_bypass_memory ;
105	_nb_cache_port = nb_cache_port ;
106	_nb_inst_memory = nb_inst_memory ;
107
108	_size_write_queue = size_write_queue ;
109	_size_execute_queue = size_execute_queue ;
110	_nb_bypass_write = nb_bypass_write ;
111	_write_queue_scheme = write_queue_scheme ;
112
113	_nb_gpr_bank = nb_gpr_bank ;
114	_nb_gpr_port_read_by_bank = nb_gpr_port_read_by_bank ;
115	_nb_gpr_port_write_by_bank = nb_gpr_port_write_by_bank ;
116	_nb_spr_bank = nb_spr_bank ;
117	_nb_spr_port_read_by_bank = nb_spr_port_read_by_bank ;
118	_nb_spr_port_write_by_bank = nb_spr_port_write_by_bank ;
119	_nb_general_register = nb_general_register ;
120	_nb_special_register = nb_special_register ;
121	_nb_inst_insert_rob = nb_inst_insert_rob ;
122	_nb_inst_retire_rob = nb_inst_retire_rob ;
123
124	_execution_unit_to_write_unit_priority = execution_unit_to_write_unit_priority;
125	_execution_unit_to_write_unit_table_routing = execution_unit_to_write_unit_table_routing;
126	_execution_unit_to_write_unit_table_thread = execution_unit_to_write_unit_table_thread ;
127
128	_read_unit_to_execution_unit_priority = read_unit_to_execution_unit_priority ;
129	_read_unit_to_execution_unit_table_routing = read_unit_to_execution_unit_table_routing ;
130	_read_unit_to_execution_unit_table_thread = read_unit_to_execution_unit_table_thread ;
131
132	_is_load_store_unit = is_load_store_unit ;
133	_translate_num_execute_unit = translate_num_execute_unit;
134
135	_nb_execute_unit = _nb_functionnal_unit + _nb_load_store_unit;
136
137	_nb_execute_unit_port = new uint32_t [_nb_execute_unit];
138
139	_read_unit_to_execution_unit_table_execute_type = new bool * [_nb_execute_unit];
140	for (uint32_t i=0; i<_nb_execute_unit; i++)
141	{
142	_read_unit_to_execution_unit_table_execute_type [i] = new bool [_nb_type];
143	for (uint32_t j=0; j<_nb_type; j++)
144	_read_unit_to_execution_unit_table_execute_type [i][j] = false;
145	}
146
147	// Fill execute_type
148	for (uint32_t i=0; i<_nb_execute_unit; i++)
149	// is load store
150	if (is_load_store_unit [i])
151	_read_unit_to_execution_unit_table_execute_type [i][TYPE_MEMORY] = true;
152	else
153	for (uint32_t j=0; j<_nb_type; j++)
154	if (is_type_valid (j))
155	for (uint32_t k=0; k<_nb_operation; k++)
156	{
157	uint32_t x = translate_num_execute_unit [i];
158	if (timing[x][j][k]._latence > 0)
159	{
160	log_printf(TRACE,Execute_loop,FUNCTION," * Execute unit '%d' (functional unit '%d') can execute type '%s'.",i,x,toString(j).c_str());
161	_read_unit_to_execution_unit_table_execute_type [i][j] = true;
162	break; // find an operation
163	}
164	}
165
166	for (uint32_t i=0; i<_nb_load_store_unit; ++i)
167	log_printf(TRACE,Execute_loop,FUNCTION," * Load_store_unit [%d] - nb_inst : %d",i,_nb_inst_memory [i]);
168	for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
169	log_printf(TRACE,Execute_loop,FUNCTION," * Functionnal_unit [%d] - nb_inst : %d",i,_nb_inst_functionnal_unit [i]);
170
171
172	for (uint32_t i=0; i<_nb_execute_unit; i++)
173	{
174	uint32_t x = translate_num_execute_unit [i];
175
176	if (_is_load_store_unit [i])
177	_nb_execute_unit_port [i] = _nb_inst_memory [x];
178	else
179	_nb_execute_unit_port [i] = _nb_inst_functionnal_unit [x];
180
181	log_printf(TRACE,Execute_loop,FUNCTION," * Execute unit [%d] (%d) - nb_inst : %d",i,x,_nb_execute_unit_port [i]);
182	}
183
184	_nb_gpr_read = 2*_nb_read_unit;
185	_nb_spr_read = 1*_nb_read_unit;
186	_nb_gpr_write = 1*_nb_write_unit;
187	_nb_spr_write = 1*_nb_write_unit;
188
189	_max_nb_general_register = max<uint32_t>(nb_general_register,nb_ooo_engine);
190	_max_nb_special_register = max<uint32_t>(nb_special_register,nb_ooo_engine);
191
192	_max_size_store_queue = max<uint32_t>(size_store_queue,nb_load_store_unit);
193	_max_size_load_queue = max<uint32_t>(size_load_queue ,nb_load_store_unit);
194
195	uint32_t _nb_thread = get_nb_thread(_nb_context,
196	_nb_front_end,
197	_nb_ooo_engine);
198
199	uint32_t _max_nb_inst_memory = max<uint32_t>(_nb_inst_memory,_nb_load_store_unit);
200
201	_set_read_unit_source_register_write = new std::set<uint32_t> [_nb_read_unit];
202	_set_read_unit_source_bypass_write = new std::set<uint32_t> [_nb_read_unit];
203	_set_read_unit_source_bypass_memory = new std::set<uint32_t> [_nb_read_unit];
204
205	_read_unit_nb_register_write = new uint32_t [_nb_read_unit];
206	_read_unit_nb_bypass_write = new uint32_t [_nb_read_unit];
207	_read_unit_nb_bypass_memory = new uint32_t [_nb_read_unit];
208
209	_link_read_unit_with_load_store_unit = new bool ** [nb_read_unit];
210	_link_read_unit_with_write_unit = new bool * [nb_read_unit];
211	_link_read_unit_with_thread = new bool * [nb_read_unit];
212
213	for (uint32_t i=0; i<_nb_read_unit; i++)
214	{
215	_read_unit_nb_register_write [i] = 0;
216	_read_unit_nb_bypass_write [i] = 0;
217	_read_unit_nb_bypass_memory [i] = 0;
218
219	_link_read_unit_with_load_store_unit [i] = new bool * [_nb_execute_unit];
220	_link_read_unit_with_write_unit [i] = new bool [_nb_write_unit];
221	_link_read_unit_with_thread [i] = new bool [_nb_thread];
222
223	for (uint32_t j=0; j<_nb_execute_unit; j++)
224	{
225	_link_read_unit_with_load_store_unit [i][j] = new bool [_max_nb_inst_memory];
226
227	for (uint32_t k=0; k<_max_nb_inst_memory; k++)
228	_link_read_unit_with_load_store_unit [i][j][k] = false;
229	}
230	for (uint32_t j=0; j<_nb_write_unit; j++)
231	_link_read_unit_with_write_unit [i][j] = false;
232	for (uint32_t j=0; j<_nb_thread; j++)
233	_link_read_unit_with_thread [i][j] = false;
234
235	// fill link array
236	for (uint32_t x=0; x<_nb_execute_unit; x++)
237	for (uint32_t y=0; y<_nb_execute_unit_port[x]; y++)
238	{
239	// Test if this read unit can send operation at this execute_unit
240	if (_read_unit_to_execution_unit_table_routing [i][x][y])
241	{
242	if (_is_load_store_unit [x])
243	{
244	_link_read_unit_with_load_store_unit [i][x][y] = true;
245	}
246
247	for (uint32_t k=0; k<_nb_thread; k++)
248	{
249	if (_read_unit_to_execution_unit_table_thread [x][k])
250	{
251	_link_read_unit_with_thread [i][k] = true;
252	}
253	}
254	// Scearch associed write_unit
255	for (uint32_t k=0; k<_nb_write_unit; k++)
256	{
257	log_printf(TRACE,Execute_loop,FUNCTION," * Execution_unit_to_write_unit_table_routing [%d][%d][%d]",x,y,k);
258
259	// Test if this execute_unit can send operation at this write_unit
260	// Test if have not a previous link ! (a same read_unit can send operation à two execute_unit and each execute_unit send at the same write_unit)
261	if (_execution_unit_to_write_unit_table_routing [x][y][k] and
262	not _link_read_unit_with_write_unit [i][k])
263	// if yes : this write_unit can have operation sended by this read_unit
264	{
265	_link_read_unit_with_write_unit [i][k] = true;
266	}
267	}
268	}
269	}
270	}
271
272	// Compute the gpr_write and spr_write port for the read_unit :
273	// * Max : 2*nb_write_unit gpr_write_port.
274	// * a specific read_unit and a specific write_unit can execute a null intersection of thread operation. Also it's unnecessarry to send the gpr_write at the read_unit.
275
276
277	// std::cout << "_link_......." << std::endl;
278	// std::cout << "_link_read_unit_with_load_store_unit" << std::endl;
279	// for (uint32_t i=0; i<_nb_read_unit; i++)
280	// {
281	// std::cout << "\t" << std::endl;
282	// for (uint32_t j=0; j<_nb_execute_unit; j++)
283	// for (uint32_t k=0; k<_nb_execute_unit_port[j]; k++)
284	// std::cout << _link_read_unit_with_load_store_unit [i][j][k] << " ";
285	// std::cout << std::endl;
286	// }
287	// std::cout << "_link_read_unit_with_write_unit" << std::endl;
288	// for (uint32_t i=0; i<_nb_read_unit; i++)
289	// {
290	// std::cout << "\t" << std::endl;
291	// for (uint32_t j=0; j<_nb_write_unit; j++)
292	// std::cout << _link_read_unit_with_write_unit [i][j] << " ";
293	// std::cout << std::endl;
294	// }
295	// std::cout << "_link_read_unit_with_thread" << std::endl;
296	// for (uint32_t i=0; i<_nb_read_unit; i++)
297	// {
298	// std::cout << "\t" << std::endl;
299	// for (uint32_t j=0; j<_nb_thread; j++)
300	// std::cout << _link_read_unit_with_thread [i][j] << " ";
301	// std::cout << std::endl;
302	// }
303
304	// std::cout << "_set_......." << std::endl;
305
306	for (uint32_t i=0; i<_nb_read_unit; i++)
307	{
308	// std::cout << " * Read_unit[" << i << "]" << std::endl;
309	for (uint32_t j=0; j<_nb_write_unit; j++)
310	{
311	// std::cout << " * Write_unit[" << j << "]" << std::endl;
312	// Test the thread executed on this write_unit
313	for (uint32_t k=0; k<_nb_thread; k++)
314	{
315	// std::cout << " * Thread[" << k << "]" << std::endl;
316	if ( (_execution_unit_to_write_unit_table_thread [j][k]) and
317	(_link_read_unit_with_thread [i][k]))
318	{
319	// std::cout << " * Find !!!!" << std::endl;
320	// std::cout << " * Read_unit "+toString(i)+" must take the gpr_write with write_unit "+toString(j)+"." << std::endl;
321	_set_read_unit_source_register_write[i].insert(j);
322	_read_unit_nb_register_write [i] ++;
323
324	// std::cout << " * bypass_write : " << _nb_bypass_write [j] << std::endl;
325	// std::cout << " * Read_unit "+toString(i)+" must take the bypass_write with write_unit "+toString(j)+"." << std::endl;
326	_set_read_unit_source_bypass_write [i].insert(j);
327	_read_unit_nb_bypass_write [i] += _nb_bypass_write [j];
328	break;
329	}
330	}
331	}
332	}
333
334	for (uint32_t i=0; i<_nb_read_unit; i++)
335	{
336	// std::cout << " * Read_unit[" << i << "]" << std::endl;
337	for (uint32_t j=0; j<_nb_execute_unit; j++)
338	{
339	uint32_t x = translate_num_execute_unit [j];
340
341	// std::cout << " * Execute_unit[" << j << "]" << std::endl;
342	// Test the thread executed on this execute_unit
343	for (uint32_t k=0; k<_nb_thread; k++)
344	{
345	// std::cout << " * Thread[" << k << "]" << std::endl;
346	if ((_read_unit_to_execution_unit_table_thread [j][k]) and
347	(_link_read_unit_with_thread [i][k]) and
348	(_is_load_store_unit [j]))
349	{
350	// std::cout << " * Find !!!!" << std::endl;
351	// std::cout << " * Bypass_memory !!!!" << std::endl;
352	// std::cout << " * Read_unit "+toString(i)+" must take the bypass_memory with load_store_unit "+toString(j)+"." << std::endl;
353
354	_set_read_unit_source_bypass_memory [i].insert(j);
355	_read_unit_nb_bypass_memory [i] += _nb_bypass_memory [x];
356
357	break; // loop on thread
358	}
359	}
360	}
361	}
362
363	uint32_t size_ooo_engine_id = log2(nb_ooo_engine );
364	uint32_t size_general_register = log2(_max_nb_general_register);
365	uint32_t size_special_register = log2(_max_nb_special_register);
366
367	test();
368
369	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : glue");
370
371	_param_glue = new morpheo::behavioural::core::multi_execute_loop::execute_loop::execute_loop_glue::Parameters
372	(_nb_gpr_write ,
373	_nb_spr_write ,
374	size_ooo_engine_id ,
375	size_general_register ,
376	size_special_register ,
377	size_general_data ,
378	size_special_data );
379
380	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit");
381
382	_param_read_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters * [_nb_read_unit];
383	for (uint32_t i=0; i<_nb_read_unit; i++)
384	_param_read_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters
385	(_size_read_queue [i],
386	_size_reservation_station [i],
387	_nb_context ,
388	_nb_front_end ,
389	_nb_ooo_engine ,
390	_nb_packet ,
391	size_general_data ,
392	size_special_data ,
393	_max_nb_general_register ,
394	_max_nb_special_register ,
395	1*_read_unit_nb_register_write [i],
396	1*_read_unit_nb_register_write [i],
397	_max_size_store_queue ,
398	_max_size_load_queue ,
399	_nb_inst_retire [i],
400	_read_unit_nb_bypass_write [i],
401	_read_unit_nb_bypass_memory [i]);
402
403	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execute_unit");
404
405	_param_functionnal_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters * [_nb_functionnal_unit];
406	_param_load_store_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters * [_nb_load_store_unit];
407
408	for (uint32_t i=0; i<_nb_execute_unit; i++)
409	{
410	uint32_t x = _translate_num_execute_unit [i];
411	if (_is_load_store_unit [i] == false)
412	_param_functionnal_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters
413	(_nb_context ,
414	_nb_front_end ,
415	_nb_ooo_engine ,
416	_nb_packet ,
417	size_general_data ,
418	_max_nb_general_register ,
419	size_special_data ,
420	_max_nb_special_register ,
421	_max_size_store_queue ,
422	_max_size_load_queue ,
423	_timing [x],
424	_get_custom_information );
425	else
426	_param_load_store_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters
427	(_size_store_queue [x],
428	_size_load_queue [x],
429	_size_speculative_access_queue [x],
430	_nb_port_check [x],
431	_speculative_load [x],
432	_nb_bypass_memory [x],
433	_nb_cache_port [x],
434	_nb_inst_memory [x],
435	_nb_context ,
436	_nb_front_end ,
437	_nb_ooo_engine ,
438	_nb_packet ,
439	size_general_data ,
440	size_special_data ,
441	_max_nb_special_register ,
442	_max_nb_general_register );
443	}
444
445	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : write_unit");
446
447	_param_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters * [_nb_write_unit];
448	for (uint32_t i=0; i<_nb_write_unit; i++)
449	_param_write_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters
450	(_size_write_queue [i],
451	_size_execute_queue [i],
452	_nb_context ,
453	_nb_front_end ,
454	_nb_ooo_engine ,
455	_nb_packet ,
456	size_general_data ,
457	_max_nb_general_register ,
458	size_special_data ,
459	_max_nb_special_register ,
460	_nb_bypass_write [i],
461	_write_queue_scheme [i]);
462
463	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit_to_execution_unit");
464
465	_param_read_unit_to_execution_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
466	(_nb_read_unit ,
467	_nb_inst_retire ,
468	_nb_execute_unit ,
469	_nb_execute_unit_port ,
470	_nb_context ,
471	_nb_front_end ,
472	_nb_ooo_engine ,
473	_nb_packet ,
474	size_general_data ,
475	size_special_data ,
476	_max_nb_general_register ,
477	_max_nb_special_register ,
478	_max_size_store_queue ,
479	_max_size_load_queue ,
480	_read_unit_to_execution_unit_priority ,
481	_read_unit_to_execution_unit_table_routing ,
482	_read_unit_to_execution_unit_table_execute_type,
483	_read_unit_to_execution_unit_table_thread );
484
485	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execution_unit_to_write_unit");
486
487	_param_execution_unit_to_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
488	(_nb_execute_unit ,
489	_nb_execute_unit_port ,
490	_nb_write_unit ,
491	_nb_context ,
492	_nb_front_end ,
493	_nb_ooo_engine ,
494	_nb_packet ,
495	size_general_data ,
496	size_special_data ,
497	_max_nb_general_register ,
498	_max_nb_special_register ,
499	_execution_unit_to_write_unit_priority ,
500	_execution_unit_to_write_unit_table_routing,
501	_execution_unit_to_write_unit_table_thread );
502
503	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : register_unit");
504
505	_param_register_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::Parameters
506	(_nb_ooo_engine ,
507	size_general_data ,
508	size_special_data ,
509	_nb_gpr_read ,
510	_nb_gpr_write ,
511	_nb_gpr_bank ,
512	_nb_gpr_port_read_by_bank ,
513	_nb_gpr_port_write_by_bank ,
514	_nb_spr_read ,
515	_nb_spr_write ,
516	_nb_spr_bank ,
517	_nb_spr_port_read_by_bank ,
518	_nb_spr_port_write_by_bank ,
519	_nb_general_register ,
520	_nb_special_register ,
521	_nb_inst_insert_rob ,
522	_nb_inst_retire_rob );
523
524	_max_size_dcache_context_id = 0;
525	_max_size_dcache_packet_id = 0;
526
527	for (uint32_t i=0; i<_nb_load_store_unit; i++)
528	{
529	if (_param_load_store_unit [i]->_size_dcache_context_id > _max_size_dcache_context_id) _max_size_dcache_context_id = _param_load_store_unit [i]->_size_dcache_context_id;
530	if (_param_load_store_unit [i]->_size_dcache_packet_id > _max_size_dcache_packet_id) _max_size_dcache_packet_id = _param_load_store_unit [i]->_size_dcache_packet_id;
531	}
532
533	_have_port_dcache_context_id = (_max_size_dcache_context_id>1);
534
535
536	if (is_toplevel)
537	{
538	_size_instruction_address= size_general_data-2;
539	_size_context_id = log2(nb_context);
540	_size_front_end_id = log2(nb_front_end);
541	_size_ooo_engine_id = size_ooo_engine_id;
542	_size_rob_ptr = log2(nb_packet);
543	_size_general_data = size_general_data;
544	_size_special_data = size_special_data;
545	_size_general_register = size_general_register;
546	_size_special_register = size_special_register;
547
548	_size_store_queue_ptr = log2(_max_size_store_queue);
549	_size_load_queue_ptr = log2(_max_size_load_queue );
550
551	_have_port_context_id = _size_context_id > 0;
552	_have_port_front_end_id = _size_front_end_id > 0;
553	_have_port_ooo_engine_id = _size_ooo_engine_id > 0;
554	_have_port_rob_ptr = _size_rob_ptr > 0;
555	_have_port_load_queue_ptr= _size_load_queue_ptr > 0;
556
557	copy();
558	}
559
560	log_printf(FUNC,Execute_loop,FUNCTION,"End");
561	};
562
563	// #undef FUNCTION
564	// #define FUNCTION "Execute_loop::Parameters (copy)"
565	// Parameters::Parameters (Parameters & param)
566	// {
567	// log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
568
569	// test();
570
571	// log_printf(FUNC,Execute_loop,FUNCTION,"End");
572	// };
573
574	#undef FUNCTION
575	#define FUNCTION "Execute_loop::~Parameters"
576	Parameters::~Parameters (void)
577	{
578	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
579
580	delete _param_glue;
581	for (uint32_t i=0; i<_nb_read_unit; i++)
582	delete _param_read_unit [i];
583	delete [] _param_read_unit;
584
585	for (uint32_t i=0; i<_nb_execute_unit; i++)
586	{
587	uint32_t x = _translate_num_execute_unit [i];
588
589	if (_is_load_store_unit [i] == false)
590	delete _param_functionnal_unit [x];
591	else
592	delete _param_load_store_unit [x];
593	}
594	delete [] _param_functionnal_unit;
595	delete [] _param_load_store_unit;
596	for (uint32_t i=0; i<_nb_write_unit; i++)
597	delete _param_write_unit [i];
598	delete [] _param_write_unit;
599	delete _param_read_unit_to_execution_unit;
600	delete _param_execution_unit_to_write_unit;
601	delete _param_register_unit;
602
603	delete [] _read_unit_to_execution_unit_table_execute_type;
604	delete [] _read_unit_nb_register_write;
605	delete [] _read_unit_nb_bypass_write;
606	delete [] _read_unit_nb_bypass_memory;
607	delete [] _set_read_unit_source_register_write ;
608	delete [] _set_read_unit_source_bypass_write ;
609	delete [] _set_read_unit_source_bypass_memory ;
610	delete [] _link_read_unit_with_load_store_unit;
611	delete [] _link_read_unit_with_write_unit;
612	delete [] _link_read_unit_with_thread;
613	delete [] _is_load_store_unit;
614	delete [] _translate_num_execute_unit;
615	delete [] _nb_execute_unit_port;
616	log_printf(FUNC,Execute_loop,FUNCTION,"End");
617	};
618
619
620	#undef FUNCTION
621	#define FUNCTION "Execute_loop::copy"
622	void Parameters::copy (void)
623	{
624	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
625
626	COPY(_param_glue);
627	for (uint32_t i=0; i<_nb_read_unit; i++)
628	COPY(_param_read_unit [i]);
629
630	for (uint32_t i=0; i<_nb_execute_unit; i++)
631	{
632	uint32_t x = _translate_num_execute_unit [i];
633
634	if (_is_load_store_unit [i] == false)
635	COPY(_param_functionnal_unit [x]);
636	else
637	COPY(_param_load_store_unit [x]);
638	}
639	for (uint32_t i=0; i<_nb_write_unit; i++)
640	COPY(_param_write_unit [i]);
641	COPY(_param_read_unit_to_execution_unit);
642	COPY(_param_execution_unit_to_write_unit);
643	COPY(_param_register_unit);
644
645	log_printf(FUNC,Execute_loop,FUNCTION,"End");
646	};
647
648	}; // end namespace execute_loop
649	}; // end namespace multi_execute_loop
650	}; // end namespace core
651
652	}; // end namespace behavioural
653	}; // end namespace morpheo

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

Download in other formats: