Context Navigation

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

Last change on this file since 124 was 124, checked in by rosiere, 15 years ago
1) Add test and configuration 2) Fix Bug 3) Add log file in load store unit 4) Fix Bug in environment
Property svn:keywords set to `Id`
File size: 30.0 KB

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

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

Download in other formats: