Context Navigation

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

Last change on this file since 136 was 136, checked in by rosiere, 15 years ago
1) Add new algo in ifetch queue 2) Add Cancel bit 3) new config
Property svn:keywords set to `Id`
File size: 30.2 KB

Line
1	/*
2	* $Id: Parameters.cpp 136 2009-10-20 18:52:15Z 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
143	_nb_thread = get_nb_thread(_nb_context,
144	_nb_front_end,
145	_nb_ooo_engine);
146	_max_nb_inst_memory = max<uint32_t>(_nb_inst_memory,_nb_load_store_unit);
147
148	ALLOC1(_nb_execute_unit_port ,uint32_t,_nb_execute_unit);
149	ALLOC2(_read_unit_to_execution_unit_table_execute_type,bool ,_nb_execute_unit,_nb_type);
150
151	for (uint32_t i=0; i<_nb_execute_unit; i++)
152	for (uint32_t j=0; j<_nb_type; j++)
153	_read_unit_to_execution_unit_table_execute_type [i][j] = false;
154
155	// Fill execute_type
156	for (uint32_t i=0; i<_nb_execute_unit; i++)
157	// is load store
158	if (is_load_store_unit [i])
159	_read_unit_to_execution_unit_table_execute_type [i][TYPE_MEMORY] = true;
160	else
161	for (uint32_t j=0; j<_nb_type; j++)
162	if (is_type_valid (j))
163	for (uint32_t k=0; k<_nb_operation; k++)
164	{
165	uint32_t x = translate_num_execute_unit [i];
166	if (timing[x][j][k]._latence > 0)
167	{
168	log_printf(TRACE,Execute_loop,FUNCTION," * Execute unit '%d' (functional unit '%d') can execute type '%s'.",i,x,toString(j).c_str());
169	_read_unit_to_execution_unit_table_execute_type [i][j] = true;
170	break; // find an operation
171	}
172	}
173
174	for (uint32_t i=0; i<_nb_load_store_unit; ++i)
175	log_printf(TRACE,Execute_loop,FUNCTION," * Load_store_unit [%d] - nb_inst : %d",i,_nb_inst_memory [i]);
176	for (uint32_t i=0; i<_nb_functionnal_unit; ++i)
177	log_printf(TRACE,Execute_loop,FUNCTION," * Functionnal_unit [%d] - nb_inst : %d",i,_nb_inst_functionnal_unit [i]);
178
179
180	for (uint32_t i=0; i<_nb_execute_unit; i++)
181	{
182	uint32_t x = translate_num_execute_unit [i];
183
184	if (_is_load_store_unit [i])
185	_nb_execute_unit_port [i] = _nb_inst_memory [x];
186	else
187	_nb_execute_unit_port [i] = _nb_inst_functionnal_unit [x];
188
189	log_printf(TRACE,Execute_loop,FUNCTION," * Execute unit [%d] (%d) - nb_inst : %d",i,x,_nb_execute_unit_port [i]);
190	}
191
192	_nb_gpr_read = 2*_nb_read_unit;
193	_nb_spr_read = 1*_nb_read_unit;
194	_nb_gpr_write = 1*_nb_write_unit;
195	_nb_spr_write = 1*_nb_write_unit;
196
197	_max_nb_general_register = max<uint32_t>(nb_general_register,nb_ooo_engine);
198	_max_nb_special_register = max<uint32_t>(nb_special_register,nb_ooo_engine);
199
200	_max_size_store_queue = max<uint32_t>(size_store_queue,nb_load_store_unit);
201	_max_size_load_queue = max<uint32_t>(size_load_queue ,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	_nb_read_unit ,
370	size_ooo_engine_id ,
371	size_general_register ,
372	size_special_register ,
373	size_general_data ,
374	size_special_data );
375
376	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit");
377
378	_param_read_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters * [_nb_read_unit];
379	for (uint32_t i=0; i<_nb_read_unit; i++)
380	_param_read_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::Parameters
381	(_size_read_queue [i],
382	_size_reservation_station [i],
383	_nb_context ,
384	_nb_front_end ,
385	_nb_ooo_engine ,
386	_nb_packet ,
387	size_general_data ,
388	size_special_data ,
389	_max_nb_general_register ,
390	_max_nb_special_register ,
391	1*_read_unit_nb_register_write [i],
392	1*_read_unit_nb_register_write [i],
393	_max_size_store_queue ,
394	_max_size_load_queue ,
395	_nb_inst_retire [i],
396	_read_unit_nb_bypass_write [i],
397	_read_unit_nb_bypass_memory [i]);
398
399	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execute_unit");
400
401	_param_functionnal_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters * [_nb_functionnal_unit];
402	_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];
403
404	for (uint32_t i=0; i<_nb_execute_unit; i++)
405	{
406	uint32_t x = _translate_num_execute_unit [i];
407	if (_is_load_store_unit [i] == false)
408	_param_functionnal_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::functionnal_unit::Parameters
409	(_nb_context ,
410	_nb_front_end ,
411	_nb_ooo_engine ,
412	_nb_packet ,
413	size_general_data ,
414	_max_nb_general_register ,
415	size_special_data ,
416	_max_nb_special_register ,
417	_max_size_store_queue ,
418	_max_size_load_queue ,
419	_timing [x],
420	_get_custom_information );
421	else
422	_param_load_store_unit [x] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_execute_unit::execute_unit::load_store_unit::Parameters
423	(_size_store_queue [x],
424	_size_load_queue [x],
425	_size_speculative_access_queue [x],
426	_nb_port_check [x],
427	_speculative_load [x],
428	_nb_bypass_memory [x],
429	_nb_cache_port [x],
430	_nb_inst_memory [x],
431	_nb_context ,
432	_nb_front_end ,
433	_nb_ooo_engine ,
434	_nb_packet ,
435	size_general_data ,
436	size_special_data ,
437	_max_nb_special_register ,
438	_max_nb_general_register ,
439	_nb_thread ,
440	_num_thread_valid );
441	}
442
443	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : write_unit");
444
445	_param_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters * [_nb_write_unit];
446	for (uint32_t i=0; i<_nb_write_unit; i++)
447	_param_write_unit [i] = new morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_write_unit::write_unit::Parameters
448	(_size_write_queue [i],
449	_size_execute_queue [i],
450	_nb_context ,
451	_nb_front_end ,
452	_nb_ooo_engine ,
453	_nb_packet ,
454	size_general_data ,
455	_max_nb_general_register ,
456	size_special_data ,
457	_max_nb_special_register ,
458	_nb_bypass_write [i],
459	_write_queue_scheme [i]);
460
461	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : read_unit_to_execution_unit");
462
463	_param_read_unit_to_execution_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::read_unit_to_execution_unit::Parameters
464	(_nb_read_unit ,
465	_nb_inst_retire ,
466	_nb_execute_unit ,
467	_nb_execute_unit_port ,
468	_nb_context ,
469	_nb_front_end ,
470	_nb_ooo_engine ,
471	_nb_packet ,
472	size_general_data ,
473	size_special_data ,
474	_max_nb_general_register ,
475	_max_nb_special_register ,
476	_max_size_store_queue ,
477	_max_size_load_queue ,
478	_read_unit_to_execution_unit_priority ,
479	_read_unit_to_execution_unit_table_routing ,
480	_read_unit_to_execution_unit_table_execute_type,
481	_read_unit_to_execution_unit_table_thread ,
482	_num_thread_valid);
483
484	log_printf(TRACE,Execute_loop,FUNCTION,"Parameters : execution_unit_to_write_unit");
485
486	_param_execution_unit_to_write_unit = new morpheo::behavioural::core::multi_execute_loop::execute_loop::network::execution_unit_to_write_unit::Parameters
487	(_nb_execute_unit ,
488	_nb_execute_unit_port ,
489	_nb_write_unit ,
490	_nb_context ,
491	_nb_front_end ,
492	_nb_ooo_engine ,
493	_nb_packet ,
494	size_general_data ,
495	size_special_data ,
496	_max_nb_general_register ,
497	_max_nb_special_register ,
498	_execution_unit_to_write_unit_priority ,
499	_execution_unit_to_write_unit_table_routing,
500	_execution_unit_to_write_unit_table_thread ,
501	_num_thread_valid);
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_read_unit // ,
522	// _nb_inst_insert_rob ,
523	// _nb_inst_retire_rob
524	);
525
526	_max_size_dcache_context_id = 0;
527	_max_size_dcache_packet_id = 0;
528
529	for (uint32_t i=0; i<_nb_load_store_unit; i++)
530	{
531	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;
532	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;
533	}
534
535	// log_printf(TRACE,Load_store_unit,FUNCTION,"kane : size_dcache_context_id : %d",_max_size_dcache_context_id );
536	// log_printf(TRACE,Load_store_unit,FUNCTION,"kane : size_dcache_packet_id : %d",_max_size_dcache_packet_id );
537
538	_have_port_dcache_context_id = (_max_size_dcache_context_id>0);
539
540	// log_printf(TRACE,Load_store_unit,FUNCTION,"kane : have_port_dcache_context_id : %d",_have_port_dcache_context_id);
541
542	if (is_toplevel)
543	{
544	_size_instruction_address= size_general_data-2;
545	_size_context_id = log2(nb_context);
546	_size_front_end_id = log2(nb_front_end);
547	_size_ooo_engine_id = size_ooo_engine_id;
548	_size_rob_ptr = log2(nb_packet);
549	_size_general_data = size_general_data;
550	_size_special_data = size_special_data;
551	_size_general_register = size_general_register;
552	_size_special_register = size_special_register;
553
554	_size_store_queue_ptr = log2(_max_size_store_queue);
555	_size_load_queue_ptr = log2(_max_size_load_queue );
556
557	_have_port_context_id = _size_context_id > 0;
558	_have_port_front_end_id = _size_front_end_id > 0;
559	_have_port_ooo_engine_id = _size_ooo_engine_id > 0;
560	_have_port_rob_ptr = _size_rob_ptr > 0;
561	_have_port_load_queue_ptr= _size_load_queue_ptr > 0;
562
563	copy();
564	}
565
566	log_printf(FUNC,Execute_loop,FUNCTION,"End");
567	};
568
569	// #undef FUNCTION
570	// #define FUNCTION "Execute_loop::Parameters (copy)"
571	// Parameters::Parameters (Parameters & param)
572	// {
573	// log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
574
575	// test();
576
577	// log_printf(FUNC,Execute_loop,FUNCTION,"End");
578	// };
579
580	#undef FUNCTION
581	#define FUNCTION "Execute_loop::~Parameters"
582	Parameters::~Parameters (void)
583	{
584	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
585
586	delete _param_glue;
587	for (uint32_t i=0; i<_nb_read_unit; i++)
588	delete _param_read_unit [i];
589	delete [] _param_read_unit;
590
591	for (uint32_t i=0; i<_nb_execute_unit; i++)
592	{
593	uint32_t x = _translate_num_execute_unit [i];
594
595	if (_is_load_store_unit [i] == false)
596	delete _param_functionnal_unit [x];
597	else
598	delete _param_load_store_unit [x];
599	}
600	delete [] _param_functionnal_unit;
601	delete [] _param_load_store_unit;
602	for (uint32_t i=0; i<_nb_write_unit; i++)
603	delete _param_write_unit [i];
604	delete [] _param_write_unit;
605	delete _param_read_unit_to_execution_unit;
606	delete _param_execution_unit_to_write_unit;
607	delete _param_register_unit;
608
609	DELETE2(_link_read_unit_with_thread ,_nb_read_unit,_nb_thread );
610	DELETE2(_link_read_unit_with_write_unit ,_nb_read_unit,_nb_write_unit );
611	DELETE3(_link_read_unit_with_load_store_unit ,_nb_read_unit,_nb_execute_unit,_max_nb_inst_memory);
612
613	DELETE1(_read_unit_nb_bypass_memory ,_nb_read_unit);
614	DELETE1(_read_unit_nb_bypass_write ,_nb_read_unit);
615	DELETE1(_read_unit_nb_register_write ,_nb_read_unit);
616
617	DELETE1(_set_read_unit_source_bypass_memory ,_nb_read_unit);
618	DELETE1(_set_read_unit_source_bypass_write ,_nb_read_unit);
619	DELETE1(_set_read_unit_source_register_write ,_nb_read_unit);
620
621	DELETE2(_read_unit_to_execution_unit_table_execute_type,_nb_execute_unit,_nb_type);
622	DELETE1(_nb_execute_unit_port ,_nb_execute_unit);
623
624	log_printf(FUNC,Execute_loop,FUNCTION,"End");
625	};
626
627
628	#undef FUNCTION
629	#define FUNCTION "Execute_loop::copy"
630	void Parameters::copy (void)
631	{
632	log_printf(FUNC,Execute_loop,FUNCTION,"Begin");
633
634	COPY(_param_glue);
635	for (uint32_t i=0; i<_nb_read_unit; i++)
636	COPY(_param_read_unit [i]);
637
638	for (uint32_t i=0; i<_nb_execute_unit; i++)
639	{
640	uint32_t x = _translate_num_execute_unit [i];
641
642	if (_is_load_store_unit [i] == false)
643	COPY(_param_functionnal_unit [x]);
644	else
645	COPY(_param_load_store_unit [x]);
646	}
647	for (uint32_t i=0; i<_nb_write_unit; i++)
648	COPY(_param_write_unit [i]);
649	COPY(_param_read_unit_to_execution_unit);
650	COPY(_param_execution_unit_to_write_unit);
651	COPY(_param_register_unit);
652
653	log_printf(FUNC,Execute_loop,FUNCTION,"End");
654	};
655
656	}; // end namespace execute_loop
657	}; // end namespace multi_execute_loop
658	}; // end namespace core
659
660	}; // end namespace behavioural
661	}; // end namespace morpheo

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

Download in other formats: