Context Navigation

Parameters.cpp @ 146

Last change on this file since 146 was 146, checked in by rosiere, 13 years ago
1) Integration of RegisterFile_Internal_Banked in RegisterFile? 2) Erase "read_write" interface in RegisterFile_Monolithic component 3) Add smith predictor parameters in Load_store_pointer_unit. 4) Fix not statistics flags
Property svn:keywords set to `Id`
File size: 32.6 KB

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

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

Context Navigation

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

Download in other formats: