Context Navigation

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

Last change on this file since 145 was 145, checked in by rosiere, 14 years ago
1) add test with SPECINT2K 2) new config of Selftest 3) modif RAT to support multiple depth_save ... but not finish (need fix Update Prediction Table) 4) add Function_pointer but need fix
Property svn:keywords set to `Id`
File size: 32.6 KB

Line
1	/*
2	* $Id: Parameters.cpp 145 2010-10-13 18:15:51Z 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.

Download in other formats: