Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Configuration/src/Instance_fromInternalStructure.cpp @ 88

Last change on this file since 88 was 88, checked in by rosiere, 15 years ago
Almost complete design with Test and test platform
Property svn:keywords set to `Id`
File size: 36.1 KB

Line
1	/*
2	* $Id: Instance_fromInternalStructure.cpp 88 2008-12-10 18:31:39Z rosiere $
3	*
4	* [ Description ]
5	*
6	*/
7
8	#include "Behavioural/Configuration/include/Instance.h"
9	#include "Behavioural/include/Allocation.h"
10	#include "Common/include/FromString.h"
11
12	namespace morpheo {
13	namespace behavioural {
14	namespace configuration {
15
16	#undef FUNCTION
17	#define FUNCTION "Instance::fromInternalStructure"
18	void Instance::fromInternalStructure (void)
19	{
20	//-----------------------------------------------------
21	// Common
22	//-----------------------------------------------------
23	log_printf(INFO,Configuration,FUNCTION,_("COMMON"));
24
25	_param->_size_general_data = fromString<uint32_t>(getParam("size_data" , ""));
26	_param->_size_special_data = SIZE_SPECIAL_DATA; // Constant
27
28	_param->_nb_thread = fromString<uint32_t>(getParam("nb_thread" , ""));
29	_param->_nb_decod_bloc = fromString<uint32_t>(getParam("nb_decod_bloc" , ""));
30	_param->_nb_rename_bloc = fromString<uint32_t>(getParam("nb_rename_bloc" , ""));
31	_param->_nb_read_bloc = fromString<uint32_t>(getParam("nb_read_bloc" , ""));
32	_param->_nb_write_bloc = fromString<uint32_t>(getParam("nb_write_bloc" , ""));
33	_param->_nb_load_store_unit = fromString<uint32_t>(getParam("nb_load_store_unit" , ""));
34	_param->_nb_functionnal_unit = fromString<uint32_t>(getParam("nb_functionnal_unit", ""));
35	_param->_nb_front_end = fromString<uint32_t>(getParam("nb_front_end" , ""));
36	_param->_nb_ooo_engine = fromString<uint32_t>(getParam("nb_ooo_engine" , ""));
37	_param->_nb_execute_loop = fromString<uint32_t>(getParam("nb_execute_loop" , ""));
38
39	//-----------------------------------------------------
40	// Thread
41	//-----------------------------------------------------
42
43	ALLOC1(_param->_size_ifetch_queue,uint32_t,_param->_nb_thread);
44	ALLOC1(_param->_nb_inst_fetch ,uint32_t,_param->_nb_thread);
45	ALLOC2(_param->_implement_group ,bool ,_param->_nb_thread,NB_GROUP);
46	ALLOC1(_param->_ras_size_queue ,uint32_t,_param->_nb_thread);
47	ALLOC1(_param->_upt_size_queue ,uint32_t,_param->_nb_thread);
48
49	for (uint32_t i=0; i<_param->_nb_thread; ++i)
50	{
51	log_printf(INFO,Configuration,FUNCTION,_("THREAD [%d]"),i);
52
53	_param->_size_ifetch_queue [i] = fromString<uint32_t>(getParam("size_ifetch_queue", "thread",toString(i).c_str(),""));
54	_param->_nb_inst_fetch [i] = fromString<uint32_t>(getParam("nb_inst_fetch" , "thread",toString(i).c_str(),""));
55	_param->_ras_size_queue [i] = fromString<uint32_t>(getParam("ras_size_queue" , "thread",toString(i).c_str(),""));
56	_param->_upt_size_queue [i] = fromString<uint32_t>(getParam("upt_size_queue" , "thread",toString(i).c_str(),""));
57
58	// just read !!!
59	try
60	{
61	getParam("nb_group","thread",toString(i).c_str(), "");
62	}
63	catch (morpheo::ErrorMorpheo & error)
64	{
65	}
66
67	for (uint32_t j=0; j<NB_GROUP; ++j)
68	{
69	_param->_implement_group [i][j] = fromString<bool>(getParam("implement_group",
70	"thread",toString(i).c_str(),
71	"group" ,toString(j).c_str(),""));
72	}
73	}
74
75	//-----------------------------------------------------
76	// Decod_bloc
77	//-----------------------------------------------------
78
79	ALLOC1(_param->_size_decod_queue ,uint32_t ,_param->_nb_decod_bloc);
80	ALLOC1(_param->_nb_inst_decod ,uint32_t ,_param->_nb_decod_bloc);
81	ALLOC1(_param->_nb_context_select ,uint32_t ,_param->_nb_decod_bloc);
82	ALLOC1(_param->_context_select_priority ,Tpriority_t ,_param->_nb_decod_bloc);
83	ALLOC1(_param->_context_select_load_balancing,Tload_balancing_t,_param->_nb_decod_bloc);
84
85	for (uint32_t i=0; i<_param->_nb_decod_bloc; ++i)
86	{
87	log_printf(INFO,Configuration,FUNCTION,_("DECOD_BLOC [%d]"),i);
88
89	_param->_size_decod_queue [i] = fromString<uint32_t > (getParam("size_decod_queue" , "decod_bloc",toString(i).c_str(),""));
90	_param->_nb_inst_decod [i] = fromString<uint32_t > (getParam("nb_inst_decod" , "decod_bloc",toString(i).c_str(),""));
91	_param->_nb_context_select [i] = fromString<uint32_t > (getParam("nb_context_select" , "decod_bloc",toString(i).c_str(),""));
92	_param->_context_select_priority [i] = fromString<Tpriority_t > (getParam("context_select_priority" , "decod_bloc",toString(i).c_str(),""));
93	_param->_context_select_load_balancing [i] = fromString<Tload_balancing_t> (getParam("context_select_load_balancing", "decod_bloc",toString(i).c_str(),""));
94	}
95
96	//-----------------------------------------------------
97	// Rename_bloc
98	//-----------------------------------------------------
99
100	ALLOC1(_param->_nb_inst_insert ,uint32_t ,_param->_nb_rename_bloc);
101	ALLOC1(_param->_nb_inst_retire ,uint32_t ,_param->_nb_rename_bloc);
102	ALLOC1(_param->_rename_select_priority ,Tpriority_t ,_param->_nb_rename_bloc);
103	ALLOC1(_param->_rename_select_load_balancing ,Tload_balancing_t,_param->_nb_rename_bloc);
104	ALLOC1(_param->_rename_select_nb_front_end_select,uint32_t ,_param->_nb_rename_bloc);
105	ALLOC1(_param->_nb_general_register ,uint32_t ,_param->_nb_rename_bloc);
106	ALLOC1(_param->_nb_special_register ,uint32_t ,_param->_nb_rename_bloc);
107	ALLOC1(_param->_nb_reg_free ,uint32_t ,_param->_nb_rename_bloc);
108	ALLOC1(_param->_nb_rename_unit_bank ,uint32_t ,_param->_nb_rename_bloc);
109	ALLOC1(_param->_size_read_counter ,uint32_t ,_param->_nb_rename_bloc);
110
111	for (uint32_t i=0; i<_param->_nb_rename_bloc; ++i)
112	{
113	log_printf(INFO,Configuration,FUNCTION,_("RENAME_BLOC [%d]"),i);
114
115	_param->_nb_inst_insert [i] = fromString<uint32_t > (getParam("nb_inst_insert" , "rename_bloc",toString(i).c_str(),""));
116	_param->_nb_inst_retire [i] = fromString<uint32_t > (getParam("nb_inst_retire" , "rename_bloc",toString(i).c_str(),""));
117	_param->_rename_select_priority [i] = fromString<Tpriority_t > (getParam("rename_select_priority" , "rename_bloc",toString(i).c_str(),""));
118	_param->_rename_select_load_balancing [i] = fromString<Tload_balancing_t> (getParam("rename_select_load_balancing" , "rename_bloc",toString(i).c_str(),""));
119	_param->_rename_select_nb_front_end_select [i] = fromString<uint32_t > (getParam("rename_select_nb_front_end_select", "rename_bloc",toString(i).c_str(),""));
120	_param->_nb_general_register [i] = fromString<uint32_t > (getParam("nb_general_register" , "rename_bloc",toString(i).c_str(),""));
121	_param->_nb_special_register [i] = fromString<uint32_t > (getParam("nb_special_register" , "rename_bloc",toString(i).c_str(),""));
122	_param->_nb_reg_free [i] = fromString<uint32_t > (getParam("nb_reg_free" , "rename_bloc",toString(i).c_str(),""));
123	_param->_nb_rename_unit_bank [i] = fromString<uint32_t > (getParam("nb_rename_unit_bank" , "rename_bloc",toString(i).c_str(),""));
124	_param->_size_read_counter [i] = fromString<uint32_t > (getParam("size_read_counter" , "rename_bloc",toString(i).c_str(),""));
125	}
126
127	//-----------------------------------------------------
128	// Read_bloc
129	//-----------------------------------------------------
130	ALLOC1(_param->_size_read_queue ,uint32_t,_param->_nb_read_bloc);
131	ALLOC1(_param->_size_reservation_station ,uint32_t,_param->_nb_read_bloc);
132	ALLOC1(_param->_nb_inst_retire_reservation_station,uint32_t,_param->_nb_read_bloc);
133
134	for (uint32_t i=0; i<_param->_nb_read_bloc; ++i)
135	{
136	log_printf(INFO,Configuration,FUNCTION,_("READ_BLOC [%d]"),i);
137
138	_param->_size_read_queue [i] = fromString<uint32_t> (getParam("size_read_queue" ,"read_bloc",toString(i).c_str(),""));
139	_param->_size_reservation_station [i] = fromString<uint32_t> (getParam("size_reservation_station" ,"read_bloc",toString(i).c_str(),""));
140	_param->_nb_inst_retire_reservation_station [i] = fromString<uint32_t> (getParam("nb_inst_retire_reservation_station","read_bloc",toString(i).c_str(),""));
141	}
142
143	//-----------------------------------------------------
144	// Write_bloc
145	//-----------------------------------------------------
146	ALLOC1(_param->_size_write_queue ,uint32_t,_param->_nb_write_bloc);
147	ALLOC1(_param->_size_execute_queue,uint32_t,_param->_nb_write_bloc);
148	ALLOC1(_param->_nb_bypass_write ,uint32_t,_param->_nb_write_bloc);
149
150	for (uint32_t i=0; i<_param->_nb_write_bloc; ++i)
151	{
152	log_printf(INFO,Configuration,FUNCTION,_("WRITE_BLOC [%d]"),i);
153
154	_param->_size_write_queue [i] = fromString<uint32_t> (getParam("size_write_queue" ,"write_bloc",toString(i).c_str(),""));
155	_param->_size_execute_queue [i] = fromString<uint32_t> (getParam("size_execute_queue","write_bloc",toString(i).c_str(),""));
156	_param->_nb_bypass_write [i] = fromString<uint32_t> (getParam("nb_bypass_write" ,"write_bloc",toString(i).c_str(),""));
157	}
158
159	//-----------------------------------------------------
160	// load_store_unit
161	//-----------------------------------------------------
162	ALLOC1(_param->_size_store_queue ,uint32_t,_param->_nb_load_store_unit);
163	ALLOC1(_param->_size_load_queue ,uint32_t,_param->_nb_load_store_unit);
164	ALLOC1(_param->_size_speculative_access_queue,uint32_t,_param->_nb_load_store_unit);
165	ALLOC1(_param->_nb_port_check ,uint32_t,_param->_nb_load_store_unit);
166	ALLOC1(_param->_nb_bypass_memory ,uint32_t,_param->_nb_load_store_unit);
167	ALLOC1(_param->_nb_cache_port ,uint32_t,_param->_nb_load_store_unit);
168	ALLOC1(_param->_nb_inst_memory ,uint32_t,_param->_nb_load_store_unit);
169	ALLOC1(_param->_speculative_load ,core::multi_execute_loop::execute_loop::Tspeculative_load_t,_param->_nb_load_store_unit);
170
171	for (uint32_t i=0; i<_param->_nb_load_store_unit; ++i)
172	{
173	log_printf(INFO,Configuration,FUNCTION,_("LOAD_STORE_UNIT [%d]"),i);
174
175	_param->_size_store_queue [i] = fromString<uint32_t> (getParam("size_store_queue" ,"load_store_unit",toString(i).c_str(),""));
176	_param->_size_load_queue [i] = fromString<uint32_t> (getParam("size_load_queue" ,"load_store_unit",toString(i).c_str(),""));
177	_param->_size_speculative_access_queue [i] = fromString<uint32_t> (getParam("size_speculative_access_queue","load_store_unit",toString(i).c_str(),""));
178	_param->_nb_port_check [i] = fromString<uint32_t> (getParam("nb_port_check" ,"load_store_unit",toString(i).c_str(),""));
179	_param->_nb_bypass_memory [i] = fromString<uint32_t> (getParam("nb_bypass_memory" ,"load_store_unit",toString(i).c_str(),""));
180	_param->_nb_cache_port [i] = fromString<uint32_t> (getParam("nb_cache_port" ,"load_store_unit",toString(i).c_str(),""));
181	_param->_nb_inst_memory [i] = fromString<uint32_t> (getParam("nb_inst_memory" ,"load_store_unit",toString(i).c_str(),""));
182
183	_param->_speculative_load [i] = fromString<core::multi_execute_loop::execute_loop::Tspeculative_load_t> (getParam("speculative_load","load_store_unit",toString(i).c_str(),""));
184	}
185
186	//-----------------------------------------------------
187	// functionnal_unit
188	//-----------------------------------------------------
189	ALLOC1(_param->_nb_inst_functionnal_unit,uint32_t,_param->_nb_functionnal_unit);
190	ALLOC3(_param->_timing,core::multi_execute_loop::execute_loop::execute_timing_t,_param->_nb_functionnal_unit,MAX_TYPE,MAX_OPERATION);
191
192	for (uint32_t i=0; i<_param->_nb_functionnal_unit; ++i)
193	{
194	log_printf(INFO,Configuration,FUNCTION,_("FUNCTIONNAL_UNIT [%d]"),i);
195
196	_param->_nb_inst_functionnal_unit [i] = fromString<uint32_t> (getParam("nb_inst_functionnal_unit","functionnal_unit",toString(i).c_str(),""));
197
198	// just read !!!
199	try
200	{
201	getParam("nb_type","functionnal_unit",toString(i).c_str(), "");
202	}
203	catch (morpheo::ErrorMorpheo & error)
204	{
205	}
206
207	for (uint32_t j=0; j<MAX_TYPE; ++j)
208	{
209	// just read !!!
210	try
211	{
212	getParam("nb_operation","functionnal_unit",toString(i).c_str(),"type",toString(j).c_str(), "");
213	}
214	catch (morpheo::ErrorMorpheo & error)
215	{
216	}
217
218
219	for (uint32_t k=0; k<MAX_OPERATION; ++k)
220	if (is_type_valid(j) and (j != TYPE_MEMORY))// A functional unit can't execute memory instruction
221	{
222	_param->_timing [i][j][k]._latence = fromString<uint32_t> (getParam("latence",
223	"functionnal_unit",toString(i).c_str(),
224	"type" ,toString(j).c_str(),
225	"operation" ,toString(k).c_str(),
226	""));
227	_param->_timing [i][j][k]._delay = fromString<uint32_t> (getParam("delay",
228	"functionnal_unit",toString(i).c_str(),
229	"type" ,toString(j).c_str(),
230	"operation" ,toString(k).c_str(),
231	""));
232	}
233	else
234	{
235	_param->_timing [i][j][k]._latence = 0;
236	_param->_timing [i][j][k]._delay = 0;
237	}
238	}
239	}
240
241	//-----------------------------------------------------
242	// icache_port
243	//-----------------------------------------------------
244
245	log_printf(INFO,Configuration,FUNCTION,_("ICACHE_PORT"));
246
247	_param->_nb_icache_port = fromString<uint32_t >(getParam("nb_icache_port" , ""));
248	_param->_icache_port_priority = fromString<Tpriority_t >(getParam("icache_port_priority" , ""));
249	_param->_icache_port_load_balancing = fromString<Tload_balancing_t >(getParam("icache_port_load_balancing", ""));
250
251	//-----------------------------------------------------
252	// dcache_port
253	//-----------------------------------------------------
254	log_printf(INFO,Configuration,FUNCTION,_("DCACHE_PORT"));
255
256	_param->_nb_dcache_port = fromString<uint32_t >(getParam("nb_dcache_port" , ""));
257	_param->_dcache_port_priority = fromString<Tpriority_t >(getParam("dcache_port_priority" , ""));
258	_param->_dcache_port_load_balancing = fromString<Tload_balancing_t >(getParam("dcache_port_load_balancing", ""));
259
260
261	//-----------------------------------------------------
262	// front_end
263	//-----------------------------------------------------
264	ALLOC1(_param->_nb_context ,uint32_t ,_param->_nb_front_end);
265	ALLOC1(_param->_nb_decod_unit ,uint32_t ,_param->_nb_front_end);
266	ALLOC1(_param->_nb_inst_branch_predict ,uint32_t ,_param->_nb_front_end);
267	ALLOC1(_param->_nb_inst_branch_decod ,uint32_t ,_param->_nb_front_end);
268	ALLOC1(_param->_nb_inst_branch_update ,uint32_t ,_param->_nb_front_end);
269	ALLOC1(_param->_btb_size_queue ,uint32_t ,_param->_nb_front_end);
270	ALLOC1(_param->_btb_associativity ,uint32_t ,_param->_nb_front_end);
271	ALLOC1(_param->_btb_size_counter ,uint32_t ,_param->_nb_front_end);
272	ALLOC1(_param->_btb_victim_scheme ,Tvictim_t ,_param->_nb_front_end);
273	ALLOC1(_param->_dir_predictor_scheme ,Tpredictor_t,_param->_nb_front_end);
274	ALLOC2(_param->_dir_have_bht ,bool ,_param->_nb_front_end,3);
275	ALLOC2(_param->_dir_bht_size_shifter ,uint32_t ,_param->_nb_front_end,3);
276	ALLOC2(_param->_dir_bht_nb_shifter ,uint32_t ,_param->_nb_front_end,3);
277	ALLOC2(_param->_dir_have_pht ,bool ,_param->_nb_front_end,3);
278	ALLOC2(_param->_dir_pht_size_counter ,uint32_t ,_param->_nb_front_end,3);
279	ALLOC2(_param->_dir_pht_nb_counter ,uint32_t ,_param->_nb_front_end,3);
280	ALLOC2(_param->_dir_pht_size_address_share ,uint32_t ,_param->_nb_front_end,3);
281
282	for (uint32_t i=0; i<_param->_nb_front_end; ++i)
283	{
284	log_printf(INFO,Configuration,FUNCTION,_("FRONT_END [%d]"),i);
285
286	_param->_nb_context [i] = fromString<uint32_t >(getParam("nb_context" ,"front_end",toString(i).c_str(), ""));
287	_param->_nb_decod_unit [i] = fromString<uint32_t >(getParam("nb_decod_unit" ,"front_end",toString(i).c_str(), ""));
288	_param->_nb_inst_branch_predict [i] = fromString<uint32_t >(getParam("nb_inst_branch_predict" ,"front_end",toString(i).c_str(), ""));
289	_param->_nb_inst_branch_decod [i] = fromString<uint32_t >(getParam("nb_inst_branch_decod" ,"front_end",toString(i).c_str(), ""));
290	_param->_nb_inst_branch_update [i] = fromString<uint32_t >(getParam("nb_inst_branch_update" ,"front_end",toString(i).c_str(), ""));
291	_param->_btb_size_queue [i] = fromString<uint32_t >(getParam("btb_size_queue" ,"front_end",toString(i).c_str(), ""));
292	_param->_btb_associativity [i] = fromString<uint32_t >(getParam("btb_associativity" ,"front_end",toString(i).c_str(), ""));
293	_param->_btb_size_counter [i] = fromString<uint32_t >(getParam("btb_size_counter" ,"front_end",toString(i).c_str(), ""));
294	_param->_btb_victim_scheme [i] = fromString<Tvictim_t >(getParam("btb_victim_scheme" ,"front_end",toString(i).c_str(), ""));
295	_param->_dir_predictor_scheme [i] = fromString<Tpredictor_t>(getParam("dir_predictor_scheme" ,"front_end",toString(i).c_str(), ""));
296
297	// just read !!!
298	try
299	{
300	getParam("nb_predictor","front_end",toString(i).c_str(), "");
301	}
302	catch (morpheo::ErrorMorpheo & error)
303	{
304	}
305
306	for (uint32_t j=0; j<3; ++j)
307	{
308	log_printf(INFO,Configuration,FUNCTION,_("PREDICTOR [%d][%d]"),i,j);
309
310	_param->_dir_have_bht [i][j] = fromString<bool >(getParam("dir_have_bht" ,"front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
311	_param->_dir_bht_size_shifter [i][j] = fromString<uint32_t >(getParam("dir_bht_size_shifter" ,"front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
312	_param->_dir_bht_nb_shifter [i][j] = fromString<uint32_t >(getParam("dir_bht_nb_shifter" ,"front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
313	_param->_dir_have_pht [i][j] = fromString<bool >(getParam("dir_have_pht" ,"front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
314	_param->_dir_pht_size_counter [i][j] = fromString<uint32_t >(getParam("dir_pht_size_counter" ,"front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
315	_param->_dir_pht_nb_counter [i][j] = fromString<uint32_t >(getParam("dir_pht_nb_counter" ,"front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
316	_param->_dir_pht_size_address_share [i][j] = fromString<uint32_t >(getParam("dir_pht_size_address_share","front_end",toString(i).c_str(),"predictor",toString(j).c_str(), ""));
317	}
318	}
319
320	//-----------------------------------------------------
321	// ooo_engine
322	//-----------------------------------------------------
323
324	ALLOC1(_param->_nb_rename_unit ,uint32_t ,_param->_nb_ooo_engine);
325	ALLOC1(_param->_nb_inst_issue ,uint32_t ,_param->_nb_ooo_engine);
326	ALLOC1(_param->_nb_inst_reexecute ,uint32_t ,_param->_nb_ooo_engine);
327	ALLOC1(_param->_nb_inst_commit ,uint32_t ,_param->_nb_ooo_engine);
328	ALLOC1(_param->_nb_inst_branch_complete ,uint32_t ,_param->_nb_ooo_engine);
329	ALLOC1(_param->_nb_rename_unit_select ,uint32_t ,_param->_nb_ooo_engine);
330	ALLOC1(_param->_nb_execute_loop_select ,uint32_t ,_param->_nb_ooo_engine);
331	ALLOC1(_param->_size_re_order_buffer ,uint32_t ,_param->_nb_ooo_engine);
332	ALLOC1(_param->_nb_re_order_buffer_bank ,uint32_t ,_param->_nb_ooo_engine);
333	ALLOC1(_param->_commit_priority ,Tpriority_t ,_param->_nb_ooo_engine);
334	ALLOC1(_param->_commit_load_balancing ,Tload_balancing_t,_param->_nb_ooo_engine);
335	ALLOC1(_param->_size_issue_queue ,uint32_t ,_param->_nb_ooo_engine);
336	ALLOC1(_param->_nb_issue_queue_bank ,uint32_t ,_param->_nb_ooo_engine);
337	ALLOC1(_param->_issue_priority ,Tpriority_t ,_param->_nb_ooo_engine);
338	ALLOC1(_param->_issue_load_balancing ,Tload_balancing_t,_param->_nb_ooo_engine);
339	ALLOC1(_param->_size_reexecute_queue ,uint32_t ,_param->_nb_ooo_engine);
340	ALLOC1(_param->_reexecute_priority ,Tpriority_t ,_param->_nb_ooo_engine);
341	ALLOC1(_param->_reexecute_load_balancing,Tload_balancing_t,_param->_nb_ooo_engine);
342
343	for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
344	{
345	log_printf(INFO,Configuration,FUNCTION,_("OOO_ENGINE [%d]"),i);
346
347	_param->_nb_rename_unit [i] = fromString<uint32_t >(getParam("nb_rename_unit" ,"ooo_engine",toString(i).c_str(), ""));
348	_param->_nb_inst_issue [i] = fromString<uint32_t >(getParam("nb_inst_issue" ,"ooo_engine",toString(i).c_str(), ""));
349	_param->_nb_inst_reexecute [i] = fromString<uint32_t >(getParam("nb_inst_reexecute" ,"ooo_engine",toString(i).c_str(), ""));
350	_param->_nb_inst_commit [i] = fromString<uint32_t >(getParam("nb_inst_commit" ,"ooo_engine",toString(i).c_str(), ""));
351	_param->_nb_inst_branch_complete [i] = fromString<uint32_t >(getParam("nb_inst_branch_complete" ,"ooo_engine",toString(i).c_str(), ""));
352	_param->_nb_rename_unit_select [i] = fromString<uint32_t >(getParam("nb_rename_unit_select" ,"ooo_engine",toString(i).c_str(), ""));
353	_param->_nb_execute_loop_select [i] = fromString<uint32_t >(getParam("nb_execute_loop_select" ,"ooo_engine",toString(i).c_str(), ""));
354	_param->_size_re_order_buffer [i] = fromString<uint32_t >(getParam("size_re_order_buffer" ,"ooo_engine",toString(i).c_str(), ""));
355	_param->_nb_re_order_buffer_bank [i] = fromString<uint32_t >(getParam("nb_re_order_buffer_bank" ,"ooo_engine",toString(i).c_str(), ""));
356	_param->_commit_priority [i] = fromString<Tpriority_t >(getParam("commit_priority" ,"ooo_engine",toString(i).c_str(), ""));
357	_param->_commit_load_balancing [i] = fromString<Tload_balancing_t>(getParam("commit_load_balancing" ,"ooo_engine",toString(i).c_str(), ""));
358	_param->_size_issue_queue [i] = fromString<uint32_t >(getParam("size_issue_queue" ,"ooo_engine",toString(i).c_str(), ""));
359	_param->_nb_issue_queue_bank [i] = fromString<uint32_t >(getParam("nb_issue_queue_bank" ,"ooo_engine",toString(i).c_str(), ""));
360	_param->_issue_priority [i] = fromString<Tpriority_t >(getParam("issue_priority" ,"ooo_engine",toString(i).c_str(), ""));
361	_param->_issue_load_balancing [i] = fromString<Tload_balancing_t>(getParam("issue_load_balancing" ,"ooo_engine",toString(i).c_str(), ""));
362	_param->_size_reexecute_queue [i] = fromString<uint32_t >(getParam("size_reexecute_queue" ,"ooo_engine",toString(i).c_str(), ""));
363	_param->_reexecute_priority [i] = fromString<Tpriority_t >(getParam("reexecute_priority" ,"ooo_engine",toString(i).c_str(), ""));
364	_param->_reexecute_load_balancing[i] = fromString<Tload_balancing_t>(getParam("reexecute_load_balancing","ooo_engine",toString(i).c_str(), ""));
365	}
366
367	//-----------------------------------------------------
368	// execute_loop
369	//-----------------------------------------------------
370
371	ALLOC1(_param->_nb_read_unit ,uint32_t ,_param->_nb_execute_loop);
372	ALLOC1(_param->_nb_execute_unit ,uint32_t ,_param->_nb_execute_loop);
373	ALLOC1(_param->_nb_write_unit ,uint32_t ,_param->_nb_execute_loop);
374	ALLOC1(_param->_nb_gpr_bank ,uint32_t ,_param->_nb_execute_loop);
375	ALLOC1(_param->_nb_gpr_port_read_by_bank ,uint32_t ,_param->_nb_execute_loop);
376	ALLOC1(_param->_nb_gpr_port_write_by_bank ,uint32_t ,_param->_nb_execute_loop);
377	ALLOC1(_param->_nb_spr_bank ,uint32_t ,_param->_nb_execute_loop);
378	ALLOC1(_param->_nb_spr_port_read_by_bank ,uint32_t ,_param->_nb_execute_loop);
379	ALLOC1(_param->_nb_spr_port_write_by_bank ,uint32_t ,_param->_nb_execute_loop);
380	ALLOC1(_param->_execution_unit_to_write_unit_priority,Tpriority_t,_param->_nb_execute_loop);
381	ALLOC1(_param->_read_unit_to_execution_unit_priority ,Tpriority_t,_param->_nb_execute_loop);
382
383	for (uint32_t i=0; i<_param->_nb_execute_loop; ++i)
384	{
385	log_printf(INFO,Configuration,FUNCTION,_("EXECUTE_LOOP [%d]"),i);
386
387	_param->_nb_read_unit [i] = fromString<uint32_t >(getParam("nb_read_unit" ,"execute_loop",toString(i).c_str(), ""));
388	_param->_nb_execute_unit [i] = fromString<uint32_t >(getParam("nb_execute_unit" ,"execute_loop",toString(i).c_str(), ""));
389	_param->_nb_write_unit [i] = fromString<uint32_t >(getParam("nb_write_unit" ,"execute_loop",toString(i).c_str(), ""));
390	_param->_nb_gpr_bank [i] = fromString<uint32_t >(getParam("nb_gpr_bank" ,"execute_loop",toString(i).c_str(), ""));
391	_param->_nb_gpr_port_read_by_bank [i] = fromString<uint32_t >(getParam("nb_gpr_port_read_by_bank" ,"execute_loop",toString(i).c_str(), ""));
392	_param->_nb_gpr_port_write_by_bank [i] = fromString<uint32_t >(getParam("nb_gpr_port_write_by_bank" ,"execute_loop",toString(i).c_str(), ""));
393	_param->_nb_spr_bank [i] = fromString<uint32_t >(getParam("nb_spr_bank" ,"execute_loop",toString(i).c_str(), ""));
394	_param->_nb_spr_port_read_by_bank [i] = fromString<uint32_t >(getParam("nb_spr_port_read_by_bank" ,"execute_loop",toString(i).c_str(), ""));
395	_param->_nb_spr_port_write_by_bank [i] = fromString<uint32_t >(getParam("nb_spr_port_write_by_bank" ,"execute_loop",toString(i).c_str(), ""));
396	_param->_execution_unit_to_write_unit_priority[i] = fromString<Tpriority_t>(getParam("execution_unit_to_write_unit_priority","execute_loop",toString(i).c_str(), ""));
397	_param->_read_unit_to_execution_unit_priority [i] = fromString<Tpriority_t>(getParam("read_unit_to_execution_unit_priority" ,"execute_loop",toString(i).c_str(), ""));
398	}
399
400	//-----------------------------------------------------
401	// Link
402	//-----------------------------------------------------
403
404	log_printf(INFO,Configuration,FUNCTION,_("LINK"));
405
406	_param->_dispatch_priority = fromString<Tpriority_t >(getParam("dispatch_priority" , ""));
407	_param->_dispatch_load_balancing = fromString<Tload_balancing_t>(getParam("dispatch_load_balancing", ""));
408
409	ALLOC1(_param->_link_context_with_thread ,pair_dual,_param->_nb_thread);
410	ALLOC1(_param->_link_decod_unit_with_decod_bloc ,pair_dual,_param->_nb_decod_bloc);
411	ALLOC1(_param->_link_rename_unit_with_rename_bloc ,pair_dual,_param->_nb_rename_bloc);
412	ALLOC1(_param->_link_read_unit_with_read_bloc ,pair_dual,_param->_nb_read_bloc);
413	ALLOC1(_param->_link_write_unit_with_write_bloc ,pair_dual,_param->_nb_write_bloc);
414	ALLOC1(_param->_link_execute_unit_with_functionnal_unit,pair_dual,_param->_nb_functionnal_unit);
415	ALLOC1(_param->_link_execute_unit_with_load_store_unit ,pair_dual,_param->_nb_load_store_unit);
416	ALLOC1(_param->_link_decod_bloc_with_thread ,uint32_t ,_param->_nb_thread);
417	ALLOC1(_param->_link_rename_bloc_with_front_end ,uint32_t ,_param->_nb_front_end);
418	ALLOC3(_param->_table_dispatch ,bool ,_param->_nb_ooo_engine,_param->_nb_inst_issue[it1],_param->_nb_read_bloc);
419	ALLOC2(_param->_link_read_bloc_and_load_store_unit ,bool ,_param->_nb_read_bloc,_param->_nb_load_store_unit);
420	ALLOC2(_param->_link_read_bloc_and_functionnal_unit ,bool ,_param->_nb_read_bloc,_param->_nb_functionnal_unit);
421	ALLOC2(_param->_link_write_bloc_and_load_store_unit ,bool ,_param->_nb_write_bloc,_param->_nb_load_store_unit);
422	ALLOC2(_param->_link_write_bloc_and_functionnal_unit ,bool ,_param->_nb_write_bloc,_param->_nb_functionnal_unit);
423	ALLOC1(_param->_link_load_store_unit_with_thread ,uint32_t ,_param->_nb_thread);
424	ALLOC2(_param->_link_thread_and_functionnal_unit ,bool ,_param->_nb_thread,_param->_nb_functionnal_unit);
425	ALLOC1(_param->_link_icache_port_with_thread ,uint32_t ,_param->_nb_thread);
426	ALLOC2(_param->_link_dcache_port_with_load_store_unit ,uint32_t ,_param->_nb_load_store_unit,_param->_nb_cache_port[it1]);
427
428	std::vector<std::string> dest;
429
430	#define getLink_n(x,nb_dest,src...) {dest = getLink(x, src); test(x,dest,nb_dest);}
431	#define getLink_2(x,src...) {getLink_n(x,2,src);}
432	#define getLink_1(x,src...) {getLink_n(x,1,src);}
433
434	for (uint32_t i=0; i<_param->_nb_thread; ++i)
435	{
436	getLink_2("link_context_with_thread",toString(i).c_str(), "");
437	_param->_link_context_with_thread [i] = pair_dual(fromString<uint32_t>(dest[0]),
438	fromString<uint32_t>(dest[1]));
439
440	getLink_1("link_decod_bloc_with_thread",toString(i).c_str(), "");
441	_param->_link_decod_bloc_with_thread [i] = fromString<uint32_t>(dest[0]);
442
443	getLink_1("link_load_store_unit_with_thread",toString(i).c_str(), "");
444	_param->_link_load_store_unit_with_thread [i] = fromString<uint32_t>(dest[0]);
445
446	getLink_1("link_icache_port_with_thread",toString(i).c_str(), "");
447	_param->_link_icache_port_with_thread [i] = fromString<uint32_t>(dest[0]);
448
449	for (uint32_t j=0; j<_param->_nb_functionnal_unit; ++j)
450	{
451	getLink_1("link_thread_and_functionnal_unit",toString(i).c_str(),toString(j).c_str(), "");
452	_param->_link_thread_and_functionnal_unit [i][j] = fromString<bool>(dest[0]);
453	}
454	}
455
456	for (uint32_t i=0; i<_param->_nb_decod_bloc; ++i)
457	{
458	getLink_2("link_decod_unit_with_decod_bloc",toString(i).c_str(), "");
459	_param->_link_decod_unit_with_decod_bloc [i] = pair_dual(fromString<uint32_t>(dest[0]),
460	fromString<uint32_t>(dest[1]));
461	}
462
463	for (uint32_t i=0; i<_param->_nb_rename_bloc; ++i)
464	{
465	getLink_2("link_rename_unit_with_rename_bloc",toString(i).c_str(), "");
466	_param->_link_rename_unit_with_rename_bloc [i] = pair_dual(fromString<uint32_t>(dest[0]),
467	fromString<uint32_t>(dest[1]));
468	}
469
470	for (uint32_t i=0; i<_param->_nb_read_bloc; ++i)
471	{
472	getLink_2("link_read_unit_with_read_bloc",toString(i).c_str(), "");
473	_param->_link_read_unit_with_read_bloc [i] = pair_dual(fromString<uint32_t>(dest[0]),
474	fromString<uint32_t>(dest[1]));
475
476	for (uint32_t j=0; j<_param->_nb_functionnal_unit; ++j)
477	{
478	getLink_1("link_read_bloc_and_functionnal_unit",toString(i).c_str(),toString(j).c_str(), "");
479	_param->_link_read_bloc_and_functionnal_unit [i][j] = fromString<bool>(dest[0]);
480	}
481
482	for (uint32_t j=0; j<_param->_nb_load_store_unit; ++j)
483	{
484	getLink_1("link_read_bloc_and_load_store_unit",toString(i).c_str(),toString(j).c_str(), "");
485	_param->_link_read_bloc_and_load_store_unit [i][j] = fromString<bool>(dest[0]);
486	}
487	}
488
489	for (uint32_t i=0; i<_param->_nb_write_bloc; ++i)
490	{
491	getLink_2("link_write_unit_with_write_bloc",toString(i).c_str(), "");
492	_param->_link_write_unit_with_write_bloc [i] = pair_dual(fromString<uint32_t>(dest[0]),
493	fromString<uint32_t>(dest[1]));
494
495	for (uint32_t j=0; j<_param->_nb_functionnal_unit; ++j)
496	{
497	getLink_1("link_write_bloc_and_functionnal_unit",toString(i).c_str(),toString(j).c_str(), "");
498	_param->_link_write_bloc_and_functionnal_unit [i][j] = fromString<bool>(dest[0]);
499	}
500
501	for (uint32_t j=0; j<_param->_nb_load_store_unit; ++j)
502	{
503	getLink_1("link_write_bloc_and_load_store_unit",toString(i).c_str(),toString(j).c_str(), "");
504	_param->_link_write_bloc_and_load_store_unit [i][j] = fromString<bool>(dest[0]);
505	}
506	}
507
508	for (uint32_t i=0; i<_param->_nb_functionnal_unit; ++i)
509	{
510	getLink_2("link_execute_unit_with_functionnal_unit",toString(i).c_str(), "");
511	_param->_link_execute_unit_with_functionnal_unit [i] = pair_dual(fromString<uint32_t>(dest[0]),
512	fromString<uint32_t>(dest[1]));
513	}
514
515	for (uint32_t i=0; i<_param->_nb_load_store_unit; ++i)
516	{
517	getLink_2("link_execute_unit_with_load_store_unit",toString(i).c_str(), "");
518	_param->_link_execute_unit_with_load_store_unit [i] = pair_dual(fromString<uint32_t>(dest[0]),
519	fromString<uint32_t>(dest[1]));
520
521	for (uint32_t j=0; j<_param->_nb_cache_port[i]; ++j)
522	{
523	getLink_1("link_dcache_port_with_load_store_unit",toString(i).c_str(),toString(j).c_str(), "");
524	_param->_link_dcache_port_with_load_store_unit [i][j] = fromString<uint32_t>(dest[0]);
525	}
526	}
527
528	for (uint32_t i=0; i<_param->_nb_front_end; ++i)
529	{
530	getLink_1("link_rename_bloc_with_front_end",toString(i).c_str(), "");
531	_param->_link_rename_bloc_with_front_end [i] = fromString<uint32_t>(dest[0]);
532	}
533
534	for (uint32_t i=0; i<_param->_nb_ooo_engine; ++i)
535	for (uint32_t j=0; j<_param->_nb_inst_issue[i]; ++j)
536	for (uint32_t k=0; k<_param->_nb_read_bloc; ++k)
537	{
538	getLink_1("table_dispatch",toString(i).c_str(),toString(j).c_str(),toString(k).c_str(),"");
539	_param->_table_dispatch [i][j][k] = fromString<bool>(dest[0]);
540	}
541
542	test_use ();
543	};
544
545	}; // end namespace configuration
546	}; // end namespace behavioural
547	}; // end namespace morpheo

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

Download in other formats: