Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/src/Parameters.cpp @ 128

Last change on this file since 128 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: 30.3 KB

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

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

Download in other formats: