1 | /* |
---|
2 | * $Id: main.cpp 88 2008-12-10 18:31:39Z rosiere $ |
---|
3 | * |
---|
4 | * [ Description ] |
---|
5 | * |
---|
6 | */ |
---|
7 | |
---|
8 | #include "Behavioural/Core/SelfTest/include/test.h" |
---|
9 | #include "Common/include/Max.h" |
---|
10 | |
---|
11 | #define NB_PARAMS 20 |
---|
12 | |
---|
13 | void usage (int argc, char * argv[]) |
---|
14 | { |
---|
15 | err (_("<Usage> %s name_instance list_params.\n"),argv[0]); |
---|
16 | err (_("list_params is :\n")); |
---|
17 | err (_(" * size_general_data (uint32_t )\n")); |
---|
18 | err (_(" * size_special_data (uint32_t )\n")); |
---|
19 | //morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void), |
---|
20 | |
---|
21 | err (_(" * nb_thread (uint32_t )\n")); |
---|
22 | err (_(" * size_ifetch_queue [nb_thread] (uint32_t )\n")); |
---|
23 | err (_(" * nb_inst_fetch [nb_thread] (uint32_t )\n")); |
---|
24 | //err (_(" * implement_group [nb_thread][NB_GROUP] (bool )\n")); |
---|
25 | err (_(" * ras_size_queue [nb_thread] (uint32_t )\n")); |
---|
26 | err (_(" * upt_size_queue [nb_thread] (uint32_t )\n")); |
---|
27 | |
---|
28 | err (_(" * nb_decod_bloc (uint32_t )\n")); |
---|
29 | err (_(" * size_decod_queue [nb_decod_bloc] (uint32_t )\n")); |
---|
30 | err (_(" * nb_inst_decod [nb_decod_bloc] (uint32_t )\n")); |
---|
31 | err (_(" * nb_context_select [nb_decod_bloc] (uint32_t )\n")); |
---|
32 | err (_(" * context_select_priority [nb_decod_bloc] (Tpriority_t )\n")); |
---|
33 | err (_(" * context_select_load_balancing [nb_decod_bloc] (Tload_balancing_t)\n")); |
---|
34 | |
---|
35 | err (_(" * nb_rename_bloc (uint32_t )\n")); |
---|
36 | err (_(" * nb_inst_insert [nb_rename_bloc] (uint32_t )\n")); |
---|
37 | err (_(" * nb_inst_retire [nb_rename_bloc] (uint32_t )\n")); |
---|
38 | err (_(" * rename_select_priority [nb_rename_bloc] (Tpriority_t )\n")); |
---|
39 | err (_(" * rename_select_load_balancing [nb_rename_bloc] (Tload_balancing_t)\n")); |
---|
40 | err (_(" * rename_select_nb_front_end_select [nb_rename_bloc] (uint32_t )\n")); |
---|
41 | err (_(" * nb_general_register [nb_rename_bloc] (uint32_t )\n")); |
---|
42 | err (_(" * nb_special_register [nb_rename_bloc] (uint32_t )\n")); |
---|
43 | err (_(" * nb_reg_free [nb_rename_bloc] (uint32_t )\n")); |
---|
44 | err (_(" * nb_rename_unit_bank [nb_rename_bloc] (uint32_t )\n")); |
---|
45 | err (_(" * size_read_counter [nb_rename_bloc] (uint32_t )\n")); |
---|
46 | |
---|
47 | err (_(" * nb_read_bloc (uint32_t )\n")); |
---|
48 | err (_(" * size_read_queue [nb_read_bloc] (uint32_t )\n")); |
---|
49 | err (_(" * size_reservation_station [nb_read_bloc] (uint32_t )\n")); |
---|
50 | err (_(" * nb_inst_retire_reservation_station [nb_read_bloc] (uint32_t )\n")); |
---|
51 | |
---|
52 | err (_(" * nb_write_bloc (uint32_t )\n")); |
---|
53 | err (_(" * size_write_queue [nb_write_bloc] (uint32_t )\n")); |
---|
54 | err (_(" * size_execute_queue [nb_write_bloc] (uint32_t )\n")); |
---|
55 | err (_(" * nb_bypass_write [nb_write_bloc] (uint32_t )\n")); |
---|
56 | |
---|
57 | err (_(" * nb_load_store_unit (uint32_t )\n")); |
---|
58 | err (_(" * size_store_queue [nb_load_store_unit] (uint32_t )\n")); |
---|
59 | err (_(" * size_load_queue [nb_load_store_unit] (uint32_t )\n")); |
---|
60 | err (_(" * size_speculative_access_queue [nb_load_store_unit] (uint32_t )\n")); |
---|
61 | err (_(" * nb_port_check [nb_load_store_unit] (uint32_t )\n")); |
---|
62 | err (_(" * speculative_load [nb_load_store_unit] (Tspeculative_load)\n")); |
---|
63 | err (_(" * nb_bypass_memory [nb_load_store_unit] (uint32_t )\n")); |
---|
64 | err (_(" * nb_cache_port [nb_load_store_unit] (uint32_t )\n")); |
---|
65 | err (_(" * nb_inst_memory [nb_load_store_unit] (uint32_t )\n")); |
---|
66 | |
---|
67 | err (_(" * nb_functionnal_unit (uint32_t )\n")); |
---|
68 | err (_(" * nb_inst_functionnal_unit [nb_functionnal_unit] (uint32_t )\n")); |
---|
69 | //err (_(" * timing [nb_functionnal_unit][nb_type][nb_operation] (execute_timing_t )\n")); |
---|
70 | |
---|
71 | err (_(" * nb_icache_port (uint32_t )\n")); |
---|
72 | err (_(" * icache_port_priority (Tpriority_t )\n")); |
---|
73 | err (_(" * icache_port_load_balancing (Tload_balancing_t)\n")); |
---|
74 | |
---|
75 | err (_(" * nb_dcache_port (uint32_t )\n")); |
---|
76 | err (_(" * dcache_port_priority (Tpriority_t )\n")); |
---|
77 | err (_(" * dcache_port_load_balancing (Tload_balancing_t)\n")); |
---|
78 | |
---|
79 | err (_(" * nb_front_end (uint32_t )\n")); |
---|
80 | err (_(" * nb_context [nb_front_end] (uint32_t )\n")); |
---|
81 | err (_(" * nb_decod_unit [nb_front_end] (uint32_t )\n")); |
---|
82 | err (_(" * nb_inst_branch_predict [nb_front_end] (uint32_t )\n")); |
---|
83 | err (_(" * nb_inst_branch_decod [nb_front_end] (uint32_t )\n")); |
---|
84 | err (_(" * nb_inst_branch_update [nb_front_end] (uint32_t )\n")); |
---|
85 | err (_(" * btb_size_queue [nb_front_end] (uint32_t )\n")); |
---|
86 | err (_(" * btb_associativity [nb_front_end] (uint32_t )\n")); |
---|
87 | err (_(" * btb_size_counter [nb_front_end] (uint32_t )\n")); |
---|
88 | err (_(" * btb_victim_scheme [nb_front_end] (Tvictim_t )\n")); |
---|
89 | err (_(" * dir_predictor_scheme [nb_front_end] (Tpredictor_t )\n")); |
---|
90 | err (_(" * dir_have_bht [nb_front_end][3] (bool )\n")); |
---|
91 | err (_(" * dir_bht_size_shifter [nb_front_end][3] (uint32_t )\n")); |
---|
92 | err (_(" * dir_bht_nb_shifter [nb_front_end][3] (uint32_t )\n")); |
---|
93 | err (_(" * dir_have_pht [nb_front_end][3] (bool )\n")); |
---|
94 | err (_(" * dir_pht_size_counter [nb_front_end][3] (uint32_t )\n")); |
---|
95 | err (_(" * dir_pht_nb_counter [nb_front_end][3] (uint32_t )\n")); |
---|
96 | err (_(" * dir_pht_size_address_share [nb_front_end][3] (uint32_t )\n")); |
---|
97 | |
---|
98 | err (_(" * nb_ooo_engine (uint32_t )\n")); |
---|
99 | err (_(" * nb_rename_unit [nb_ooo_engine] (uint32_t )\n")); |
---|
100 | err (_(" * nb_inst_issue [nb_ooo_engine] (uint32_t )\n")); |
---|
101 | err (_(" * nb_inst_reexecute [nb_ooo_engine] (uint32_t )\n")); |
---|
102 | err (_(" * nb_inst_commit [nb_ooo_engine] (uint32_t )\n")); |
---|
103 | err (_(" * nb_inst_branch_complete [nb_ooo_engine] (uint32_t )\n")); |
---|
104 | err (_(" * nb_rename_unit_select [nb_ooo_engine] (uint32_t )\n")); |
---|
105 | err (_(" * nb_execute_loop_select [nb_ooo_engine] (uint32_t )\n")); |
---|
106 | err (_(" * size_re_order_buffer [nb_ooo_engine] (uint32_t )\n")); |
---|
107 | err (_(" * nb_re_order_buffer_bank [nb_ooo_engine] (uint32_t )\n")); |
---|
108 | err (_(" * commit_priority [nb_ooo_engine] (Tpriority_t )\n")); |
---|
109 | err (_(" * commit_load_balancing [nb_ooo_engine] (Tload_balancing_t)\n")); |
---|
110 | err (_(" * size_issue_queue [nb_ooo_engine] (uint32_t )\n")); |
---|
111 | err (_(" * nb_issue_queue_bank [nb_ooo_engine] (uint32_t )\n")); |
---|
112 | err (_(" * issue_priority [nb_ooo_engine] (Tpriority_t )\n")); |
---|
113 | err (_(" * issue_load_balancing [nb_ooo_engine] (Tload_balancing_t)\n")); |
---|
114 | err (_(" * size_reexecute_queue [nb_ooo_engine] (uint32_t )\n")); |
---|
115 | err (_(" * reexecute_priority [nb_ooo_engine] (Tpriority_t )\n")); |
---|
116 | err (_(" * reexecute_load_balancing [nb_ooo_engine] (Tload_balancing_t)\n")); |
---|
117 | |
---|
118 | err (_(" * nb_execute_loop (uint32_t )\n")); |
---|
119 | err (_(" * nb_read_unit [nb_execute_loop] (uint32_t )\n")); |
---|
120 | err (_(" * nb_execute_unit [nb_execute_loop] (uint32_t )\n")); |
---|
121 | err (_(" * nb_write_unit [nb_execute_loop] (uint32_t )\n")); |
---|
122 | err (_(" * nb_gpr_bank [nb_execute_loop] (uint32_t )\n")); |
---|
123 | err (_(" * nb_gpr_port_read_by_bank [nb_execute_loop] (uint32_t )\n")); |
---|
124 | err (_(" * nb_gpr_port_write_by_bank [nb_execute_loop] (uint32_t )\n")); |
---|
125 | err (_(" * nb_spr_bank [nb_execute_loop] (uint32_t )\n")); |
---|
126 | err (_(" * nb_spr_port_read_by_bank [nb_execute_loop] (uint32_t )\n")); |
---|
127 | err (_(" * nb_spr_port_write_by_bank [nb_execute_loop] (uint32_t )\n")); |
---|
128 | err (_(" * execution_unit_to_write_unit_priority [nb_execute_loop] (Tpriority_t )\n")); |
---|
129 | err (_(" * read_unit_to_execution_unit_priority [nb_execute_loop] (Tpriority_t )\n")); |
---|
130 | |
---|
131 | err (_(" * link_context_with_thread [nb_thread] (pair_dual )\n")); |
---|
132 | err (_(" * link_decod_unit_with_decod_bloc [nb_decod_bloc] (pair_dual )\n")); |
---|
133 | err (_(" * link_rename_unit_with_rename_bloc [nb_rename_bloc] (pair_dual )\n")); |
---|
134 | err (_(" * link_read_unit_with_read_bloc [nb_read_bloc] (pair_dual )\n")); |
---|
135 | err (_(" * link_write_unit_with_write_bloc [nb_write_bloc] (pair_dual )\n")); |
---|
136 | err (_(" * link_execute_unit_with_functionnal_unit [nb_functionnal_unit] (pair_dual )\n")); |
---|
137 | err (_(" * link_execute_unit_with_load_store_unit [nb_load_store_unit] (pair_dual )\n")); |
---|
138 | err (_(" * link_decod_bloc_with_thread [nb_thread] (uint32_t )\n")); |
---|
139 | err (_(" * link_rename_bloc_with_front_end [nb_front_end] (uint32_t )\n")); |
---|
140 | err (_(" * table_dispatch [nb_ooo_engine][nb_inst_issue][nb_read_bloc] (bool )\n")); |
---|
141 | err (_(" * link_read_bloc_and_load_store_unit [nb_read_bloc][nb_load_store_unit] (bool )\n")); |
---|
142 | err (_(" * link_read_bloc_and_functionnal_unit [nb_read_bloc][nb_functionnal_unit] (bool )\n")); |
---|
143 | err (_(" * link_write_bloc_and_load_store_unit [nb_write_bloc][nb_load_store_unit] (bool )\n")); |
---|
144 | err (_(" * link_write_bloc_and_functionnal_unit [nb_write_bloc][nb_functionnal_unit] (bool )\n")); |
---|
145 | err (_(" * link_load_store_unit_with_thread [nb_thread] (uint32_t )\n")); |
---|
146 | err (_(" * link_thread_and_functionnal_unit [nb_thread][nb_functionnal_unit] (bool )\n")); |
---|
147 | err (_(" * link_icache_port_with_thread [nb_thread] (uint32_t )\n")); |
---|
148 | err (_(" * link_dcache_port_with_load_store_unit [nb_load_store_unit][nb_cache_port] (uint32_t )\n")); |
---|
149 | |
---|
150 | err (_(" * dispatch_priority (Tpriority_t )\n")); |
---|
151 | err (_(" * dispatch_load_balancing (Tload_balancing_t)\n")); |
---|
152 | err (_("\n")); |
---|
153 | err (_(" - pair_dual : first = x div 1000, second = x mod 1000\n")); |
---|
154 | err (_("\n")); |
---|
155 | err (_(" - now they have %d\n"),argc); |
---|
156 | |
---|
157 | exit (1); |
---|
158 | } |
---|
159 | |
---|
160 | #ifndef SYSTEMC |
---|
161 | int main (int argc, char * argv[]) |
---|
162 | #else |
---|
163 | int sc_main (int argc, char * argv[]) |
---|
164 | #endif |
---|
165 | { |
---|
166 | if (argc < static_cast<int>(2+NB_PARAMS)) |
---|
167 | usage (argc, argv); |
---|
168 | |
---|
169 | uint32_t x = 1; |
---|
170 | |
---|
171 | string name = argv[x++]; |
---|
172 | |
---|
173 | // Common |
---|
174 | uint32_t _size_general_data ; |
---|
175 | uint32_t _size_special_data ; |
---|
176 | morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void); |
---|
177 | |
---|
178 | // Thread |
---|
179 | uint32_t _nb_thread ; |
---|
180 | uint32_t * _size_ifetch_queue ;//[nb_thread] |
---|
181 | uint32_t * _nb_inst_fetch ;//[nb_thread] |
---|
182 | bool ** _implement_group ;//[nb_thread][NB_GROUP] |
---|
183 | uint32_t * _ras_size_queue ;//[nb_thread] |
---|
184 | uint32_t * _upt_size_queue ;//[nb_thread] |
---|
185 | |
---|
186 | // Decod_bloc |
---|
187 | uint32_t _nb_decod_bloc ;// |
---|
188 | uint32_t * _size_decod_queue ;//[nb_decod_bloc] |
---|
189 | uint32_t * _nb_inst_decod ;//[nb_decod_bloc] |
---|
190 | uint32_t * _nb_context_select ;//[nb_decod_bloc] |
---|
191 | Tpriority_t * _context_select_priority ;//[nb_decod_bloc] |
---|
192 | Tload_balancing_t * _context_select_load_balancing ;//[nb_decod_bloc] |
---|
193 | |
---|
194 | // Rename_bloc |
---|
195 | uint32_t _nb_rename_bloc ;// |
---|
196 | uint32_t * _nb_inst_insert ;//[nb_rename_bloc] |
---|
197 | uint32_t * _nb_inst_retire ;//[nb_rename_bloc] |
---|
198 | Tpriority_t * _rename_select_priority ;//[nb_rename_bloc] |
---|
199 | Tload_balancing_t * _rename_select_load_balancing ;//[nb_rename_bloc] |
---|
200 | uint32_t * _rename_select_nb_front_end_select ;//[nb_rename_bloc] |
---|
201 | uint32_t * _nb_general_register ;//[nb_rename_bloc] |
---|
202 | uint32_t * _nb_special_register ;//[nb_rename_bloc] |
---|
203 | uint32_t * _nb_reg_free ;//[nb_rename_bloc] |
---|
204 | uint32_t * _nb_rename_unit_bank ;//[nb_rename_bloc] |
---|
205 | uint32_t * _size_read_counter ;//[nb_rename_bloc] |
---|
206 | |
---|
207 | // Read bloc |
---|
208 | uint32_t _nb_read_bloc ;// |
---|
209 | uint32_t * _size_read_queue ;//[nb_read_bloc] |
---|
210 | uint32_t * _size_reservation_station ;//[nb_read_bloc] |
---|
211 | uint32_t * _nb_inst_retire_reservation_station ;//[nb_read_bloc] |
---|
212 | |
---|
213 | // Write bloc |
---|
214 | uint32_t _nb_write_bloc ;// |
---|
215 | uint32_t * _size_write_queue ;//[nb_write_bloc] |
---|
216 | uint32_t * _size_execute_queue ;//[nb_write_bloc] |
---|
217 | uint32_t * _nb_bypass_write ;//[nb_write_bloc] |
---|
218 | |
---|
219 | // Load_store_unit |
---|
220 | uint32_t _nb_load_store_unit ; |
---|
221 | uint32_t * _size_store_queue ;//[nb_load_store_unit] |
---|
222 | uint32_t * _size_load_queue ;//[nb_load_store_unit] |
---|
223 | uint32_t * _size_speculative_access_queue ;//[nb_load_store_unit] |
---|
224 | uint32_t * _nb_port_check ;//[nb_load_store_unit] |
---|
225 | multi_execute_loop::execute_loop::Tspeculative_load_t |
---|
226 | * _speculative_load ;//[nb_load_store_unit] |
---|
227 | uint32_t * _nb_bypass_memory ;//[nb_load_store_unit] |
---|
228 | uint32_t * _nb_cache_port ;//[nb_load_store_unit] |
---|
229 | uint32_t * _nb_inst_memory ;//[nb_load_store_unit] |
---|
230 | |
---|
231 | // Functionnal_unit |
---|
232 | uint32_t _nb_functionnal_unit ; |
---|
233 | uint32_t * _nb_inst_functionnal_unit ;//[nb_functionnal_unit] |
---|
234 | multi_execute_loop::execute_loop::execute_timing_t |
---|
235 | *** _timing ;//[nb_functionnal_unit][nb_type][nb_operation] |
---|
236 | |
---|
237 | // Icache_Access |
---|
238 | uint32_t _nb_icache_port ; |
---|
239 | Tpriority_t _icache_port_priority ; |
---|
240 | Tload_balancing_t _icache_port_load_balancing ; |
---|
241 | |
---|
242 | // Dcache_Access |
---|
243 | uint32_t _nb_dcache_port ; |
---|
244 | Tpriority_t _dcache_port_priority ; |
---|
245 | Tload_balancing_t _dcache_port_load_balancing ; |
---|
246 | |
---|
247 | // Front_end |
---|
248 | uint32_t _nb_front_end ; |
---|
249 | uint32_t * _nb_context ;//[nb_front_end] |
---|
250 | uint32_t * _nb_decod_unit ;//[nb_front_end] |
---|
251 | uint32_t * _nb_inst_branch_predict ;//[nb_front_end] |
---|
252 | uint32_t * _nb_inst_branch_decod ;//[nb_front_end] |
---|
253 | uint32_t * _nb_inst_branch_update ;//[nb_front_end] |
---|
254 | uint32_t * _btb_size_queue ;//[nb_front_end] |
---|
255 | uint32_t * _btb_associativity ;//[nb_front_end] |
---|
256 | uint32_t * _btb_size_counter ;//[nb_front_end] |
---|
257 | Tvictim_t * _btb_victim_scheme ;//[nb_front_end] |
---|
258 | Tpredictor_t * _dir_predictor_scheme ;//[nb_front_end] |
---|
259 | bool ** _dir_have_bht ;//[nb_front_end][3] |
---|
260 | uint32_t ** _dir_bht_size_shifter ;//[nb_front_end][3] |
---|
261 | uint32_t ** _dir_bht_nb_shifter ;//[nb_front_end][3] |
---|
262 | bool ** _dir_have_pht ;//[nb_front_end][3] |
---|
263 | uint32_t ** _dir_pht_size_counter ;//[nb_front_end][3] |
---|
264 | uint32_t ** _dir_pht_nb_counter ;//[nb_front_end][3] |
---|
265 | uint32_t ** _dir_pht_size_address_share ;//[nb_front_end][3] |
---|
266 | |
---|
267 | // OOO_Engine |
---|
268 | uint32_t _nb_ooo_engine ; |
---|
269 | uint32_t * _nb_rename_unit ;//[nb_ooo_engine] |
---|
270 | uint32_t * _nb_inst_issue ;//[nb_ooo_engine] |
---|
271 | uint32_t * _nb_inst_reexecute ;//[nb_ooo_engine] |
---|
272 | uint32_t * _nb_inst_commit ;//[nb_ooo_engine] |
---|
273 | uint32_t * _nb_inst_branch_complete ;//[nb_ooo_engine] |
---|
274 | uint32_t * _nb_rename_unit_select ;//[nb_ooo_engine] |
---|
275 | uint32_t * _nb_execute_loop_select ;//[nb_ooo_engine] |
---|
276 | uint32_t * _size_re_order_buffer ;//[nb_ooo_engine] |
---|
277 | uint32_t * _nb_re_order_buffer_bank ;//[nb_ooo_engine] |
---|
278 | Tpriority_t * _commit_priority ;//[nb_ooo_engine] |
---|
279 | Tload_balancing_t * _commit_load_balancing ;//[nb_ooo_engine] |
---|
280 | uint32_t * _size_issue_queue ;//[nb_ooo_engine] |
---|
281 | uint32_t * _nb_issue_queue_bank ;//[nb_ooo_engine] |
---|
282 | Tpriority_t * _issue_priority ;//[nb_ooo_engine] |
---|
283 | Tload_balancing_t * _issue_load_balancing ;//[nb_ooo_engine] |
---|
284 | uint32_t * _size_reexecute_queue ;//[nb_ooo_engine] |
---|
285 | Tpriority_t * _reexecute_priority ;//[nb_ooo_engine] |
---|
286 | Tload_balancing_t * _reexecute_load_balancing ;//[nb_ooo_engine] |
---|
287 | |
---|
288 | // Execute_loop |
---|
289 | uint32_t _nb_execute_loop ; |
---|
290 | uint32_t * _nb_read_unit ;//[nb_execute_loop] |
---|
291 | uint32_t * _nb_execute_unit ;//[nb_execute_loop] |
---|
292 | uint32_t * _nb_write_unit ;//[nb_execute_loop] |
---|
293 | uint32_t * _nb_gpr_bank ;//[nb_execute_loop] |
---|
294 | uint32_t * _nb_gpr_port_read_by_bank ;//[nb_execute_loop] |
---|
295 | uint32_t * _nb_gpr_port_write_by_bank ;//[nb_execute_loop] |
---|
296 | uint32_t * _nb_spr_bank ;//[nb_execute_loop] |
---|
297 | uint32_t * _nb_spr_port_read_by_bank ;//[nb_execute_loop] |
---|
298 | uint32_t * _nb_spr_port_write_by_bank ;//[nb_execute_loop] |
---|
299 | Tpriority_t * _execution_unit_to_write_unit_priority ;//[nb_execute_loop] |
---|
300 | Tpriority_t * _read_unit_to_execution_unit_priority ;//[nb_execute_loop] |
---|
301 | |
---|
302 | // Link |
---|
303 | pair_dual * _link_context_with_thread ;//[nb_thread] |
---|
304 | pair_dual * _link_decod_unit_with_decod_bloc ;//[nb_decod_bloc] |
---|
305 | pair_dual * _link_rename_unit_with_rename_bloc ;//[nb_rename_bloc] |
---|
306 | pair_dual * _link_read_unit_with_read_bloc ;//[nb_read_bloc] |
---|
307 | pair_dual * _link_write_unit_with_write_bloc ;//[nb_write_bloc] |
---|
308 | pair_dual * _link_execute_unit_with_functionnal_unit ;//[nb_functionnal_unit] |
---|
309 | pair_dual * _link_execute_unit_with_load_store_unit ;//[nb_load_store_unit] |
---|
310 | uint32_t * _link_decod_bloc_with_thread ;//[nb_thread] |
---|
311 | uint32_t * _link_rename_bloc_with_front_end ;//[nb_front_end] |
---|
312 | bool *** _table_dispatch ;//[nb_ooo_engine][nb_inst_issue][nb_read_bloc] |
---|
313 | bool ** _link_read_bloc_and_load_store_unit ;//[nb_read_bloc][nb_load_store_unit] |
---|
314 | bool ** _link_read_bloc_and_functionnal_unit ;//[nb_read_bloc][nb_functionnal_unit] |
---|
315 | bool ** _link_write_bloc_and_load_store_unit ;//[nb_write_bloc][nb_load_store_unit] |
---|
316 | bool ** _link_write_bloc_and_functionnal_unit ;//[nb_write_bloc][nb_functionnal_unit] |
---|
317 | uint32_t * _link_load_store_unit_with_thread ;//[nb_thread] |
---|
318 | bool ** _link_thread_and_functionnal_unit ;//[nb_thread][nb_functionnal_unit] |
---|
319 | uint32_t * _link_icache_port_with_thread ;//[nb_thread] |
---|
320 | uint32_t ** _link_dcache_port_with_load_store_unit ;//[nb_load_store_unit][nb_cache_port] |
---|
321 | |
---|
322 | Tpriority_t _dispatch_priority ; |
---|
323 | Tload_balancing_t _dispatch_load_balancing ; |
---|
324 | |
---|
325 | printf("Core parameters :\n"); |
---|
326 | |
---|
327 | // Common |
---|
328 | printf(" * Common\n"); |
---|
329 | SELFTEST0(_size_general_data ,uint32_t ,argv,x); |
---|
330 | SELFTEST0(_size_special_data ,uint32_t ,argv,x); |
---|
331 | _get_custom_information = &(morpheo::behavioural::custom::default_get_custom_information); |
---|
332 | |
---|
333 | //Thread |
---|
334 | printf(" * Thread\n"); |
---|
335 | SELFTEST0(_nb_thread ,uint32_t ,argv,x); |
---|
336 | |
---|
337 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread)) |
---|
338 | usage (argc, argv); |
---|
339 | |
---|
340 | SELFTEST1(_size_ifetch_queue ,uint32_t ,argv,x,_nb_thread); |
---|
341 | SELFTEST1(_nb_inst_fetch ,uint32_t ,argv,x,_nb_thread); |
---|
342 | ALLOC2 (_implement_group ,bool ,_nb_thread,NB_GROUP); |
---|
343 | for (uint32_t i=0; i<_nb_thread; ++i) |
---|
344 | for (uint32_t j=0; j<NB_GROUP; ++j) |
---|
345 | _implement_group[i][j] = true; |
---|
346 | SELFTEST1(_ras_size_queue ,uint32_t ,argv,x,_nb_thread); |
---|
347 | SELFTEST1(_upt_size_queue ,uint32_t ,argv,x,_nb_thread); |
---|
348 | |
---|
349 | // Decod bloc |
---|
350 | printf(" * Decod bloc\n"); |
---|
351 | SELFTEST0(_nb_decod_bloc ,uint32_t ,argv,x); |
---|
352 | |
---|
353 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc)) |
---|
354 | usage (argc, argv); |
---|
355 | |
---|
356 | SELFTEST1(_size_decod_queue ,uint32_t ,argv,x,_nb_decod_bloc); |
---|
357 | SELFTEST1(_nb_inst_decod ,uint32_t ,argv,x,_nb_decod_bloc); |
---|
358 | SELFTEST1(_nb_context_select ,uint32_t ,argv,x,_nb_decod_bloc); |
---|
359 | SELFTEST1(_context_select_priority ,Tpriority_t ,argv,x,_nb_decod_bloc); |
---|
360 | SELFTEST1(_context_select_load_balancing ,Tload_balancing_t ,argv,x,_nb_decod_bloc); |
---|
361 | |
---|
362 | // Rename bloc |
---|
363 | printf(" * Rename bloc\n"); |
---|
364 | SELFTEST0(_nb_rename_bloc ,uint32_t ,argv,x); |
---|
365 | |
---|
366 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc)) |
---|
367 | usage (argc, argv); |
---|
368 | |
---|
369 | SELFTEST1(_nb_inst_insert ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
370 | SELFTEST1(_nb_inst_retire ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
371 | SELFTEST1(_rename_select_priority ,Tpriority_t ,argv,x,_nb_rename_bloc); |
---|
372 | SELFTEST1(_rename_select_load_balancing ,Tload_balancing_t ,argv,x,_nb_rename_bloc); |
---|
373 | SELFTEST1(_rename_select_nb_front_end_select ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
374 | SELFTEST1(_nb_general_register ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
375 | SELFTEST1(_nb_special_register ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
376 | SELFTEST1(_nb_reg_free ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
377 | SELFTEST1(_nb_rename_unit_bank ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
378 | SELFTEST1(_size_read_counter ,uint32_t ,argv,x,_nb_rename_bloc); |
---|
379 | |
---|
380 | // Read bloc |
---|
381 | printf(" * Read bloc\n"); |
---|
382 | SELFTEST0(_nb_read_bloc ,uint32_t ,argv,x); |
---|
383 | |
---|
384 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc)) |
---|
385 | usage (argc, argv); |
---|
386 | |
---|
387 | SELFTEST1(_size_read_queue ,uint32_t ,argv,x,_nb_read_bloc); |
---|
388 | SELFTEST1(_size_reservation_station ,uint32_t ,argv,x,_nb_read_bloc); |
---|
389 | SELFTEST1(_nb_inst_retire_reservation_station ,uint32_t ,argv,x,_nb_read_bloc); |
---|
390 | |
---|
391 | // Write bloc |
---|
392 | printf(" * Write bloc\n"); |
---|
393 | SELFTEST0(_nb_write_bloc ,uint32_t ,argv,x); |
---|
394 | |
---|
395 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc+3*_nb_write_bloc)) |
---|
396 | usage (argc, argv); |
---|
397 | |
---|
398 | SELFTEST1(_size_write_queue ,uint32_t ,argv,x,_nb_write_bloc); |
---|
399 | SELFTEST1(_size_execute_queue ,uint32_t ,argv,x,_nb_write_bloc); |
---|
400 | SELFTEST1(_nb_bypass_write ,uint32_t ,argv,x,_nb_write_bloc); |
---|
401 | |
---|
402 | // Load store unit |
---|
403 | printf(" * Load store unit\n"); |
---|
404 | SELFTEST0(_nb_load_store_unit ,uint32_t ,argv,x); |
---|
405 | |
---|
406 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc+3*_nb_write_bloc+8*_nb_load_store_unit)) |
---|
407 | usage (argc, argv); |
---|
408 | |
---|
409 | SELFTEST1(_size_store_queue ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
410 | SELFTEST1(_size_load_queue ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
411 | SELFTEST1(_size_speculative_access_queue ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
412 | SELFTEST1(_nb_port_check ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
413 | SELFTEST1(_speculative_load ,multi_execute_loop::execute_loop::Tspeculative_load_t |
---|
414 | ,argv,x,_nb_load_store_unit); |
---|
415 | SELFTEST1(_nb_bypass_memory ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
416 | SELFTEST1(_nb_cache_port ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
417 | SELFTEST1(_nb_inst_memory ,uint32_t ,argv,x,_nb_load_store_unit); |
---|
418 | |
---|
419 | // Functionnal_unit |
---|
420 | printf(" * Functional unit\n"); |
---|
421 | SELFTEST0(_nb_functionnal_unit ,uint32_t ,argv,x); |
---|
422 | |
---|
423 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc+3*_nb_write_bloc+8*_nb_load_store_unit+1*_nb_functionnal_unit)) |
---|
424 | usage (argc, argv); |
---|
425 | |
---|
426 | SELFTEST1(_nb_inst_functionnal_unit ,uint32_t ,argv,x,_nb_functionnal_unit); |
---|
427 | ALLOC3 (_timing ,multi_execute_loop::execute_loop::execute_timing_t,_nb_functionnal_unit,MAX_TYPE,MAX_OPERATION); |
---|
428 | |
---|
429 | for (uint32_t i=0; i< _nb_functionnal_unit; i++) |
---|
430 | for (uint32_t j=0; j< MAX_TYPE; j++) |
---|
431 | if ((j == TYPE_ALU ) | |
---|
432 | (j == TYPE_SHIFT ) | |
---|
433 | (j == TYPE_MOVE ) | |
---|
434 | (j == TYPE_TEST ) | |
---|
435 | (j == TYPE_MUL ) | |
---|
436 | (j == TYPE_DIV ) | |
---|
437 | (j == TYPE_EXTEND ) | |
---|
438 | (j == TYPE_FIND ) | |
---|
439 | (j == TYPE_SPECIAL) | |
---|
440 | (j == TYPE_CUSTOM ) | |
---|
441 | (j == TYPE_BRANCH ) // | |
---|
442 | // (j == TYPE_MEMORY ) |
---|
443 | ) |
---|
444 | for (uint32_t k=0; k< MAX_OPERATION; k++) |
---|
445 | _timing [i][j][k]._delay = _timing [i][j][k]._latence = 1; |
---|
446 | |
---|
447 | // Icache_Access |
---|
448 | printf(" * Icache access\n"); |
---|
449 | |
---|
450 | SELFTEST0(_nb_icache_port ,uint32_t ,argv,x); |
---|
451 | SELFTEST0(_icache_port_priority ,Tpriority_t ,argv,x); |
---|
452 | SELFTEST0(_icache_port_load_balancing ,Tload_balancing_t ,argv,x); |
---|
453 | |
---|
454 | // Dcache_Access |
---|
455 | printf(" * Dcache access\n"); |
---|
456 | |
---|
457 | SELFTEST0(_nb_dcache_port ,uint32_t ,argv,x); |
---|
458 | SELFTEST0(_dcache_port_priority ,Tpriority_t ,argv,x); |
---|
459 | SELFTEST0(_dcache_port_load_balancing ,Tload_balancing_t ,argv,x); |
---|
460 | |
---|
461 | // Front_end |
---|
462 | printf(" * Front end\n"); |
---|
463 | |
---|
464 | SELFTEST0(_nb_front_end ,uint32_t ,argv,x); |
---|
465 | |
---|
466 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc+3*_nb_write_bloc+8*_nb_load_store_unit+1*_nb_functionnal_unit+31*_nb_front_end)) |
---|
467 | usage (argc, argv); |
---|
468 | |
---|
469 | SELFTEST1(_nb_context ,uint32_t ,argv,x,_nb_front_end); |
---|
470 | SELFTEST1(_nb_decod_unit ,uint32_t ,argv,x,_nb_front_end); |
---|
471 | SELFTEST1(_nb_inst_branch_predict ,uint32_t ,argv,x,_nb_front_end); |
---|
472 | SELFTEST1(_nb_inst_branch_decod ,uint32_t ,argv,x,_nb_front_end); |
---|
473 | SELFTEST1(_nb_inst_branch_update ,uint32_t ,argv,x,_nb_front_end); |
---|
474 | SELFTEST1(_btb_size_queue ,uint32_t ,argv,x,_nb_front_end); |
---|
475 | SELFTEST1(_btb_associativity ,uint32_t ,argv,x,_nb_front_end); |
---|
476 | SELFTEST1(_btb_size_counter ,uint32_t ,argv,x,_nb_front_end); |
---|
477 | SELFTEST1(_btb_victim_scheme ,Tvictim_t ,argv,x,_nb_front_end); |
---|
478 | SELFTEST1(_dir_predictor_scheme ,Tpredictor_t ,argv,x,_nb_front_end); |
---|
479 | |
---|
480 | SELFTEST2(_dir_have_bht ,bool ,argv,x,_nb_front_end,3); |
---|
481 | SELFTEST2(_dir_bht_size_shifter ,uint32_t ,argv,x,_nb_front_end,3); |
---|
482 | SELFTEST2(_dir_bht_nb_shifter ,uint32_t ,argv,x,_nb_front_end,3); |
---|
483 | SELFTEST2(_dir_have_pht ,bool ,argv,x,_nb_front_end,3); |
---|
484 | SELFTEST2(_dir_pht_size_counter ,uint32_t ,argv,x,_nb_front_end,3); |
---|
485 | SELFTEST2(_dir_pht_nb_counter ,uint32_t ,argv,x,_nb_front_end,3); |
---|
486 | SELFTEST2(_dir_pht_size_address_share ,uint32_t ,argv,x,_nb_front_end,3); |
---|
487 | |
---|
488 | // OOO_Engine |
---|
489 | printf(" * OOO Engine\n"); |
---|
490 | |
---|
491 | SELFTEST0(_nb_ooo_engine ,uint32_t ,argv,x); |
---|
492 | |
---|
493 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc+3*_nb_write_bloc+8*_nb_load_store_unit+1*_nb_functionnal_unit+31*_nb_front_end+18*_nb_ooo_engine)) |
---|
494 | usage (argc, argv); |
---|
495 | |
---|
496 | SELFTEST1(_nb_rename_unit ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
497 | SELFTEST1(_nb_inst_issue ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
498 | SELFTEST1(_nb_inst_reexecute ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
499 | SELFTEST1(_nb_inst_commit ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
500 | SELFTEST1(_nb_inst_branch_complete ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
501 | SELFTEST1(_nb_rename_unit_select ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
502 | SELFTEST1(_nb_execute_loop_select ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
503 | SELFTEST1(_size_re_order_buffer ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
504 | SELFTEST1(_nb_re_order_buffer_bank ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
505 | SELFTEST1(_commit_priority ,Tpriority_t ,argv,x,_nb_ooo_engine); |
---|
506 | SELFTEST1(_commit_load_balancing ,Tload_balancing_t ,argv,x,_nb_ooo_engine); |
---|
507 | SELFTEST1(_size_issue_queue ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
508 | SELFTEST1(_nb_issue_queue_bank ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
509 | SELFTEST1(_issue_priority ,Tpriority_t ,argv,x,_nb_ooo_engine); |
---|
510 | SELFTEST1(_issue_load_balancing ,Tload_balancing_t ,argv,x,_nb_ooo_engine); |
---|
511 | SELFTEST1(_size_reexecute_queue ,uint32_t ,argv,x,_nb_ooo_engine); |
---|
512 | SELFTEST1(_reexecute_priority ,Tpriority_t ,argv,x,_nb_ooo_engine); |
---|
513 | SELFTEST1(_reexecute_load_balancing ,Tload_balancing_t ,argv,x,_nb_ooo_engine); |
---|
514 | |
---|
515 | //Execute_loop |
---|
516 | printf(" * Execute Loop\n"); |
---|
517 | |
---|
518 | SELFTEST0(_nb_execute_loop ,uint32_t ,argv,x); |
---|
519 | |
---|
520 | if (argc < static_cast<int>(2+NB_PARAMS+4*_nb_thread+5*_nb_decod_bloc+10*_nb_rename_bloc+3*_nb_read_bloc+3*_nb_write_bloc+8*_nb_load_store_unit+1*_nb_functionnal_unit+31*_nb_front_end+18*_nb_ooo_engine+11*_nb_execute_loop)) |
---|
521 | usage (argc, argv); |
---|
522 | |
---|
523 | SELFTEST1(_nb_read_unit ,uint32_t ,argv,x,_nb_execute_loop); |
---|
524 | SELFTEST1(_nb_execute_unit ,uint32_t ,argv,x,_nb_execute_loop); |
---|
525 | SELFTEST1(_nb_write_unit ,uint32_t ,argv,x,_nb_execute_loop); |
---|
526 | SELFTEST1(_nb_gpr_bank ,uint32_t ,argv,x,_nb_execute_loop); |
---|
527 | SELFTEST1(_nb_gpr_port_read_by_bank ,uint32_t ,argv,x,_nb_execute_loop); |
---|
528 | SELFTEST1(_nb_gpr_port_write_by_bank ,uint32_t ,argv,x,_nb_execute_loop); |
---|
529 | SELFTEST1(_nb_spr_bank ,uint32_t ,argv,x,_nb_execute_loop); |
---|
530 | SELFTEST1(_nb_spr_port_read_by_bank ,uint32_t ,argv,x,_nb_execute_loop); |
---|
531 | SELFTEST1(_nb_spr_port_write_by_bank ,uint32_t ,argv,x,_nb_execute_loop); |
---|
532 | SELFTEST1(_execution_unit_to_write_unit_priority ,Tpriority_t ,argv,x,_nb_execute_loop); |
---|
533 | SELFTEST1(_read_unit_to_execution_unit_priority ,Tpriority_t ,argv,x,_nb_execute_loop); |
---|
534 | |
---|
535 | // Link |
---|
536 | printf(" * Link\n"); |
---|
537 | |
---|
538 | if (argc < static_cast<int>(2+NB_PARAMS+5*_nb_thread+6*_nb_decod_bloc+11*_nb_rename_bloc+4*_nb_read_bloc+4*_nb_write_bloc+9*_nb_load_store_unit+2*_nb_functionnal_unit+31*_nb_front_end+18*_nb_ooo_engine+11*_nb_execute_loop)) |
---|
539 | usage (argc, argv); |
---|
540 | |
---|
541 | ALLOC1 (_link_context_with_thread ,pair_dual ,_nb_thread); |
---|
542 | ALLOC1 (_link_decod_unit_with_decod_bloc ,pair_dual ,_nb_decod_bloc); |
---|
543 | ALLOC1 (_link_rename_unit_with_rename_bloc ,pair_dual ,_nb_rename_bloc); |
---|
544 | ALLOC1 (_link_read_unit_with_read_bloc ,pair_dual ,_nb_read_bloc); |
---|
545 | ALLOC1 (_link_write_unit_with_write_bloc ,pair_dual ,_nb_write_bloc); |
---|
546 | ALLOC1 (_link_execute_unit_with_functionnal_unit ,pair_dual ,_nb_functionnal_unit); |
---|
547 | ALLOC1 (_link_execute_unit_with_load_store_unit ,pair_dual ,_nb_load_store_unit); |
---|
548 | |
---|
549 | for (uint32_t i=0; i<_nb_thread; ++i) |
---|
550 | { |
---|
551 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
552 | _link_context_with_thread [i] = pair_dual(tmp/1000,tmp%1000); |
---|
553 | } |
---|
554 | for (uint32_t i=0; i<_nb_decod_bloc; ++i) |
---|
555 | { |
---|
556 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
557 | _link_decod_unit_with_decod_bloc [i] = pair_dual(tmp/1000,tmp%1000); |
---|
558 | } |
---|
559 | for (uint32_t i=0; i<_nb_rename_bloc; ++i) |
---|
560 | { |
---|
561 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
562 | _link_rename_unit_with_rename_bloc [i] = pair_dual(tmp/1000,tmp%1000); |
---|
563 | } |
---|
564 | for (uint32_t i=0; i<_nb_read_bloc; ++i) |
---|
565 | { |
---|
566 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
567 | _link_read_unit_with_read_bloc [i] = pair_dual(tmp/1000,tmp%1000); |
---|
568 | } |
---|
569 | for (uint32_t i=0; i<_nb_write_bloc; ++i) |
---|
570 | { |
---|
571 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
572 | _link_write_unit_with_write_bloc [i] = pair_dual(tmp/1000,tmp%1000); |
---|
573 | } |
---|
574 | for (uint32_t i=0; i<_nb_functionnal_unit; ++i) |
---|
575 | { |
---|
576 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
577 | _link_execute_unit_with_functionnal_unit [i] = pair_dual(tmp/1000,tmp%1000); |
---|
578 | } |
---|
579 | for (uint32_t i=0; i<_nb_load_store_unit; ++i) |
---|
580 | { |
---|
581 | uint32_t tmp=fromString<uint32_t>(argv[x++]); |
---|
582 | _link_execute_unit_with_load_store_unit [i] = pair_dual(tmp/1000,tmp%1000); |
---|
583 | } |
---|
584 | |
---|
585 | uint32_t _sum_inst_issue = 0; |
---|
586 | for (uint32_t i=0; i<_nb_ooo_engine;++i) |
---|
587 | _sum_inst_issue += _nb_inst_issue[i]; |
---|
588 | uint32_t _sum_cache_port = 0; |
---|
589 | for (uint32_t i=0; i<_nb_load_store_unit;++i) |
---|
590 | _sum_cache_port += _nb_cache_port[i]; |
---|
591 | |
---|
592 | if (argc != static_cast<int>(2+NB_PARAMS+5*_nb_thread+6*_nb_decod_bloc+11*_nb_rename_bloc+4*_nb_read_bloc+4*_nb_write_bloc+9*_nb_load_store_unit+2*_nb_functionnal_unit+31*_nb_front_end+18*_nb_ooo_engine+11*_nb_execute_loop+ |
---|
593 | 3*_nb_thread+_nb_front_end+_sum_inst_issue*_nb_read_bloc+_nb_load_store_unit*(_nb_read_bloc+_nb_write_bloc+_nb_thread)+_nb_functionnal_unit*(_nb_read_bloc+_nb_write_bloc)+_sum_cache_port)) |
---|
594 | usage (argc, argv); |
---|
595 | |
---|
596 | SELFTEST1(_link_decod_bloc_with_thread ,uint32_t ,argv,x,_nb_thread); |
---|
597 | SELFTEST1(_link_rename_bloc_with_front_end ,uint32_t ,argv,x,_nb_front_end); |
---|
598 | SELFTEST3(_table_dispatch ,bool ,argv,x,_nb_ooo_engine,_nb_inst_issue[it1],_nb_read_bloc); |
---|
599 | SELFTEST2(_link_read_bloc_and_load_store_unit ,bool ,argv,x,_nb_read_bloc,_nb_load_store_unit); |
---|
600 | SELFTEST2(_link_read_bloc_and_functionnal_unit ,bool ,argv,x,_nb_read_bloc,_nb_functionnal_unit); |
---|
601 | SELFTEST2(_link_write_bloc_and_load_store_unit ,bool ,argv,x,_nb_write_bloc,_nb_load_store_unit); |
---|
602 | SELFTEST2(_link_write_bloc_and_functionnal_unit ,bool ,argv,x,_nb_write_bloc,_nb_functionnal_unit); |
---|
603 | SELFTEST1(_link_load_store_unit_with_thread ,uint32_t ,argv,x,_nb_thread); |
---|
604 | SELFTEST2(_link_thread_and_functionnal_unit ,bool ,argv,x,_nb_thread,_nb_functionnal_unit); |
---|
605 | SELFTEST1(_link_icache_port_with_thread ,uint32_t ,argv,x,_nb_thread); |
---|
606 | SELFTEST2(_link_dcache_port_with_load_store_unit ,uint32_t ,argv,x,_nb_load_store_unit,_nb_cache_port[it1]); |
---|
607 | SELFTEST0(_dispatch_priority ,Tpriority_t ,argv,x); |
---|
608 | SELFTEST0(_dispatch_load_balancing ,Tload_balancing_t ,argv,x); |
---|
609 | |
---|
610 | printf(" * End parameters\n"); |
---|
611 | printf("--------------------------------\n"); |
---|
612 | |
---|
613 | int _return = EXIT_SUCCESS; |
---|
614 | try |
---|
615 | { |
---|
616 | morpheo::behavioural::core::Parameters * param = new morpheo::behavioural::core::Parameters |
---|
617 | ( |
---|
618 | _size_general_data , |
---|
619 | _size_special_data , |
---|
620 | _get_custom_information , |
---|
621 | |
---|
622 | _nb_thread , |
---|
623 | _size_ifetch_queue , |
---|
624 | _nb_inst_fetch , |
---|
625 | _implement_group , |
---|
626 | _ras_size_queue , |
---|
627 | _upt_size_queue , |
---|
628 | |
---|
629 | _nb_decod_bloc , |
---|
630 | _size_decod_queue , |
---|
631 | _nb_inst_decod , |
---|
632 | _nb_context_select , |
---|
633 | _context_select_priority , |
---|
634 | _context_select_load_balancing , |
---|
635 | |
---|
636 | _nb_rename_bloc , |
---|
637 | _nb_inst_insert , |
---|
638 | _nb_inst_retire , |
---|
639 | _rename_select_priority , |
---|
640 | _rename_select_load_balancing , |
---|
641 | _rename_select_nb_front_end_select , |
---|
642 | _nb_general_register , |
---|
643 | _nb_special_register , |
---|
644 | _nb_reg_free , |
---|
645 | _nb_rename_unit_bank , |
---|
646 | _size_read_counter , |
---|
647 | |
---|
648 | _nb_read_bloc , |
---|
649 | _size_read_queue , |
---|
650 | _size_reservation_station , |
---|
651 | _nb_inst_retire_reservation_station , |
---|
652 | |
---|
653 | _nb_write_bloc , |
---|
654 | _size_write_queue , |
---|
655 | _size_execute_queue , |
---|
656 | _nb_bypass_write , |
---|
657 | |
---|
658 | _nb_load_store_unit , |
---|
659 | _size_store_queue , |
---|
660 | _size_load_queue , |
---|
661 | _size_speculative_access_queue , |
---|
662 | _nb_port_check , |
---|
663 | _speculative_load , |
---|
664 | _nb_bypass_memory , |
---|
665 | _nb_cache_port , |
---|
666 | _nb_inst_memory , |
---|
667 | |
---|
668 | _nb_functionnal_unit , |
---|
669 | _nb_inst_functionnal_unit , |
---|
670 | _timing , |
---|
671 | |
---|
672 | _nb_icache_port , |
---|
673 | _icache_port_priority , |
---|
674 | _icache_port_load_balancing , |
---|
675 | |
---|
676 | _nb_dcache_port , |
---|
677 | _dcache_port_priority , |
---|
678 | _dcache_port_load_balancing , |
---|
679 | |
---|
680 | _nb_front_end , |
---|
681 | _nb_context , |
---|
682 | _nb_decod_unit , |
---|
683 | _nb_inst_branch_predict , |
---|
684 | _nb_inst_branch_decod , |
---|
685 | _nb_inst_branch_update , |
---|
686 | _btb_size_queue , |
---|
687 | _btb_associativity , |
---|
688 | _btb_size_counter , |
---|
689 | _btb_victim_scheme , |
---|
690 | _dir_predictor_scheme , |
---|
691 | _dir_have_bht , |
---|
692 | _dir_bht_size_shifter , |
---|
693 | _dir_bht_nb_shifter , |
---|
694 | _dir_have_pht , |
---|
695 | _dir_pht_size_counter , |
---|
696 | _dir_pht_nb_counter , |
---|
697 | _dir_pht_size_address_share , |
---|
698 | |
---|
699 | _nb_ooo_engine , |
---|
700 | _nb_rename_unit , |
---|
701 | _nb_inst_issue , |
---|
702 | _nb_inst_reexecute , |
---|
703 | _nb_inst_commit , |
---|
704 | _nb_inst_branch_complete , |
---|
705 | _nb_rename_unit_select , |
---|
706 | _nb_execute_loop_select , |
---|
707 | _size_re_order_buffer , |
---|
708 | _nb_re_order_buffer_bank , |
---|
709 | _commit_priority , |
---|
710 | _commit_load_balancing , |
---|
711 | _size_issue_queue , |
---|
712 | _nb_issue_queue_bank , |
---|
713 | _issue_priority , |
---|
714 | _issue_load_balancing , |
---|
715 | _size_reexecute_queue , |
---|
716 | _reexecute_priority , |
---|
717 | _reexecute_load_balancing , |
---|
718 | |
---|
719 | _nb_execute_loop , |
---|
720 | _nb_read_unit , |
---|
721 | _nb_execute_unit , |
---|
722 | _nb_write_unit , |
---|
723 | _nb_gpr_bank , |
---|
724 | _nb_gpr_port_read_by_bank , |
---|
725 | _nb_gpr_port_write_by_bank , |
---|
726 | _nb_spr_bank , |
---|
727 | _nb_spr_port_read_by_bank , |
---|
728 | _nb_spr_port_write_by_bank , |
---|
729 | _execution_unit_to_write_unit_priority , |
---|
730 | _read_unit_to_execution_unit_priority , |
---|
731 | |
---|
732 | _link_context_with_thread , |
---|
733 | _link_decod_unit_with_decod_bloc , |
---|
734 | _link_rename_unit_with_rename_bloc , |
---|
735 | _link_read_unit_with_read_bloc , |
---|
736 | _link_write_unit_with_write_bloc , |
---|
737 | _link_execute_unit_with_functionnal_unit , |
---|
738 | _link_execute_unit_with_load_store_unit , |
---|
739 | _link_decod_bloc_with_thread , |
---|
740 | _link_rename_bloc_with_front_end , |
---|
741 | _table_dispatch , |
---|
742 | _link_read_bloc_and_load_store_unit , |
---|
743 | _link_read_bloc_and_functionnal_unit , |
---|
744 | _link_write_bloc_and_load_store_unit , |
---|
745 | _link_write_bloc_and_functionnal_unit , |
---|
746 | _link_load_store_unit_with_thread , |
---|
747 | _link_thread_and_functionnal_unit , |
---|
748 | _link_icache_port_with_thread , |
---|
749 | _link_dcache_port_with_load_store_unit , |
---|
750 | |
---|
751 | _dispatch_priority , |
---|
752 | _dispatch_load_balancing |
---|
753 | ); |
---|
754 | |
---|
755 | test (name,param); |
---|
756 | } |
---|
757 | catch (morpheo::ErrorMorpheo & error) |
---|
758 | { |
---|
759 | msg (_("<%s> :\n%s"),name.c_str(), error.what ()); |
---|
760 | _return = EXIT_FAILURE; |
---|
761 | } |
---|
762 | |
---|
763 | try |
---|
764 | { |
---|
765 | if (_return == EXIT_SUCCESS) |
---|
766 | TEST_OK("Core : no error"); |
---|
767 | else |
---|
768 | TEST_KO("Core : a lot of error"); |
---|
769 | } |
---|
770 | catch (morpheo::ErrorMorpheo & error) |
---|
771 | { |
---|
772 | // msg (_("<%s> :\n%s"),name.c_str(), error.what ()); |
---|
773 | _return = EXIT_FAILURE; |
---|
774 | } |
---|
775 | |
---|
776 | return (_return); |
---|
777 | } |
---|