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