source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/src/main.cpp @ 131

Last change on this file since 131 was 131, checked in by rosiere, 15 years ago

1) add constant method
2) test with systemc 2.2.0
  • Property svn:keywords set to Id
File size: 21.8 KB
Line 
1/*
2 * $Id: main.cpp 131 2009-07-08 18:40:08Z rosiere $
3 *
4 * [ Description ]
5 *
6 */
7
8#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/SelfTest/include/test.h"
9#include "Behavioural/include/Allocation.h"
10
11#define NB_PARAMS 18
12
13void 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 (_(" * nb_read_unit                                                                                     (uint32_t           )\n"));
18  err (_(" * nb_functionnal_unit                                                                              (uint32_t           )\n"));
19  err (_(" * nb_load_store_unit                                                                               (uint32_t           )\n"));
20  err (_(" * nb_write_unit                                                                                    (uint32_t           )\n"));
21  err (_(" * nb_context                                                                                       (uint32_t           )\n"));
22  err (_(" * nb_front_end                                                                                     (uint32_t           )\n"));
23  err (_(" * nb_ooo_engine                                                                                    (uint32_t           )\n"));
24  err (_(" * nb_packet                                                                                        (uint32_t           )\n"));
25  err (_(" * size_general_data                                                                                (uint32_t           )\n"));
26  err (_(" * size_special_data                                                                                (uint32_t           )\n"));
27  err (_(" * size_read_queue                           [nb_read_unit]                                         (uint32_t           )\n"));
28  err (_(" * size_reservation_station                  [nb_read_unit]                                         (uint32_t           )\n"));
29  err (_(" * nb_inst_retire                            [nb_read_unit]                                         (uint32_t           )\n"));
30  err (_(" * nb_inst_functionnal_unit                  [nb_functionnal_unit]                                  (uint32_t           )\n"));
31  err (_(" * size_store_queue                          [nb_load_store_unit]                                   (uint32_t           )\n"));
32  err (_(" * size_load_queue                           [nb_load_store_unit]                                   (uint32_t           )\n"));
33  err (_(" * size_speculative_access_queue             [nb_load_store_unit]                                   (uint32_t           )\n"));
34  err (_(" * nb_port_check                             [nb_load_store_unit]                                   (uint32_t           )\n"));
35  err (_(" * speculative_load                          [nb_load_store_unit]                                   (Tspeculative_load_t)\n"));
36  err (_(" * nb_bypass_memory                          [nb_load_store_unit]                                   (uint32_t           )\n"));
37  err (_(" * nb_cache_port                             [nb_load_store_unit]                                   (uint32_t           )\n"));
38  err (_(" * nb_inst_memory                            [nb_load_store_unit]                                   (uint32_t           )\n"));
39  err (_(" * size_write_queue                          [nb_write_unit]                                        (uint32_t           )\n"));
40  err (_(" * size_execute_queue                        [nb_write_unit]                                        (uint32_t           )\n"));
41  err (_(" * nb_bypass_write                           [nb_write_unit]                                        (uint32_t           )\n"));
42  err (_(" * write_queue_scheme                        [nb_write_unit]                                        (Twrite_queue_scheme_t)\n"));
43  err (_(" * nb_gpr_bank                                                                                      (uint32_t           )\n"));
44  err (_(" * nb_gpr_port_read_by_bank                                                                         (uint32_t           )\n"));
45  err (_(" * nb_gpr_port_write_by_bank                                                                        (uint32_t           )\n"));
46  err (_(" * nb_spr_bank                                                                                      (uint32_t           )\n"));
47  err (_(" * nb_spr_port_read_by_bank                                                                         (uint32_t           )\n"));
48  err (_(" * nb_spr_port_write_by_bank                                                                        (uint32_t           )\n"));
49  err (_(" * nb_general_register                       [nb_ooo_engine]                                        (uint32_t           )\n"));
50  err (_(" * nb_special_register                       [nb_ooo_engine]                                        (uint32_t           )\n"));
51  err (_(" * nb_inst_insert_rob                        [nb_ooo_engine]                                        (uint32_t           )\n"));
52  err (_(" * nb_inst_retire_rob                        [nb_ooo_engine]                                        (uint32_t           )\n"));
53  err (_(" * execution_unit_to_write_unit_priority                                                            (Tpriority_t        )\n"));
54  err (_(" * execution_unit_to_write_unit_table_routing[nb_execute_unit][nb_execute_unit_port][nb_write_unit] (bool               )\n"));
55  err (_(" * execution_unit_to_write_unit_table_thread [nb_write_unit][nb_thread]                             (bool               )\n"));
56  err (_(" * read_unit_to_execution_unit_priority                                                             (Tpriority_t        )\n"));
57  err (_(" * read_unit_to_execution_unit_table_routing [nb_read_unit][nb_execute_unit][nb_execute_unit_port]  (bool               )\n"));
58  err (_(" * read_unit_to_execution_unit_table_thread  [nb_execute_unit][nb_thread]                           (bool               )\n"));
59  err (_(" * is_load_store_unit                        [nb_execute_unit]                                      (bool               )\n"));
60  err (_(" * translate_num_execute_unit                [nb_execute_unit]                                      (uint32_t           )\n"));
61
62
63  exit (1);
64}
65
66#ifndef SYSTEMC
67int main    (int argc, char * argv[])
68#else
69int sc_main (int argc, char * argv[])
70#endif
71{
72  // Command
73  for (int32_t i=0; i<argc; ++i)
74    msg("%s ",argv[i]);
75  msg("\n");
76 
77  if (argc < 2+NB_PARAMS)
78    usage (argc, argv);
79
80  uint32_t       x = 1;
81
82  string                name                =      argv[x++];
83  uint32_t              nb_read_unit        = atoi(argv[x++]);
84  uint32_t              nb_functionnal_unit = atoi(argv[x++]);
85  uint32_t              nb_load_store_unit  = atoi(argv[x++]);
86  uint32_t              nb_write_unit       = atoi(argv[x++]);
87  uint32_t              nb_context          = atoi(argv[x++]);
88  uint32_t              nb_front_end        = atoi(argv[x++]);
89  uint32_t              nb_ooo_engine       = atoi(argv[x++]);
90  uint32_t              nb_packet           = atoi(argv[x++]);
91  uint32_t              size_general_data   = atoi(argv[x++]);
92  uint32_t              size_special_data   = atoi(argv[x++]);
93
94  uint32_t nb_execute_unit = nb_functionnal_unit + nb_load_store_unit;
95  uint32_t nb_thread       = get_nb_thread(nb_context, nb_front_end, nb_ooo_engine);
96
97  int32_t nb_params = (2+NB_PARAMS+
98                       3*nb_read_unit+
99                       1*nb_functionnal_unit+
100                       8*nb_load_store_unit+
101                       4*nb_write_unit+
102                       4*nb_ooo_engine+
103//                     sum_execute_unit_port*nb_write_unit+
104                       nb_write_unit*nb_thread+
105//                     nb_read_unit*sum_execute_unit_port+
106                       nb_execute_unit*nb_thread+
107                       2*nb_execute_unit);
108 
109  if (argc <= nb_params)
110    usage (argc, argv);
111 
112  uint32_t            * size_read_queue          = new uint32_t [nb_read_unit];
113  for (uint32_t i=0; i<nb_read_unit; i++)
114    size_read_queue [i] = atoi(argv[x++]);
115
116  uint32_t            * size_reservation_station = new uint32_t [nb_read_unit];
117  for (uint32_t i=0; i<nb_read_unit; i++)
118    size_reservation_station [i] = atoi(argv[x++]);
119
120  uint32_t            * nb_inst_retire           = new uint32_t [nb_read_unit];
121  for (uint32_t i=0; i<nb_read_unit; i++)
122    nb_inst_retire [i] = atoi(argv[x++]);
123
124  uint32_t            * nb_inst_functionnal_unit = new uint32_t [nb_functionnal_unit];
125  for (uint32_t i=0; i<nb_functionnal_unit; i++)
126    nb_inst_functionnal_unit [i] = atoi(argv[x++]);
127
128  uint32_t          * size_store_queue              = new uint32_t [nb_load_store_unit];
129  for (uint32_t i=0; i<nb_load_store_unit; i++)
130    size_store_queue              [i] = atoi(argv[x++]);
131
132  uint32_t          * size_load_queue               = new uint32_t [nb_load_store_unit];
133  for (uint32_t i=0; i<nb_load_store_unit; i++)
134    size_load_queue               [i] = atoi(argv[x++]);
135
136  uint32_t          * size_speculative_access_queue = new uint32_t [nb_load_store_unit];
137  for (uint32_t i=0; i<nb_load_store_unit; i++)
138    size_speculative_access_queue [i] = atoi(argv[x++]);
139
140  uint32_t          * nb_port_check                 = new uint32_t [nb_load_store_unit];
141  for (uint32_t i=0; i<nb_load_store_unit; i++)
142    nb_port_check                 [i] = atoi(argv[x++]);
143
144  Tspeculative_load_t * speculative_load            = new Tspeculative_load_t [nb_load_store_unit];
145  for (uint32_t i=0; i<nb_load_store_unit; i++)
146    speculative_load              [i] = fromString<Tspeculative_load_t>(argv[x++]);
147
148  uint32_t          * nb_bypass_memory              = new uint32_t [nb_load_store_unit];
149  for (uint32_t i=0; i<nb_load_store_unit; i++)
150    nb_bypass_memory              [i] = atoi(argv[x++]);
151
152  uint32_t          * nb_cache_port                 = new uint32_t [nb_load_store_unit];
153  for (uint32_t i=0; i<nb_load_store_unit; i++)
154    nb_cache_port                 [i] = atoi(argv[x++]);
155
156  uint32_t          * nb_inst_memory                = new uint32_t [nb_load_store_unit];
157  for (uint32_t i=0; i<nb_load_store_unit; i++)
158    nb_inst_memory                [i] = atoi(argv[x++]);
159
160
161  uint32_t sum_execute_unit_port = 0;
162  for (uint32_t i=0; i<nb_load_store_unit; i++)
163    sum_execute_unit_port += nb_inst_memory[i];
164  for (uint32_t i=0; i<nb_functionnal_unit; i++)
165    sum_execute_unit_port += nb_inst_functionnal_unit[i];
166
167  nb_params = (2+NB_PARAMS+
168               3*nb_read_unit+
169               1*nb_functionnal_unit+
170               8*nb_load_store_unit+
171               4*nb_write_unit+
172               4*nb_ooo_engine+
173               sum_execute_unit_port*nb_write_unit+
174               nb_write_unit*nb_thread+
175               nb_read_unit*sum_execute_unit_port+
176               nb_execute_unit*nb_thread+
177               2*nb_execute_unit);
178 
179  if (argc != nb_params)
180    {
181      msg("nb_functionnal_unit   : %d\n",nb_functionnal_unit);
182      msg("nb_load_store_unit    : %d\n",nb_load_store_unit );
183      msg("sum_execute_unit_port : %d.\n",sum_execute_unit_port);
184      msg(_("Have %d parameters.\n"),argc     );
185      msg(_("Need %d parameters.\n"),nb_params);
186      usage (argc, argv);
187    }
188
189  uint32_t * size_write_queue   = new uint32_t [nb_write_unit];
190  for (uint32_t i=0; i<nb_write_unit; i++)
191    size_write_queue   [i] = atoi(argv[x++]);
192 
193  uint32_t * size_execute_queue = new uint32_t [nb_write_unit];
194  for (uint32_t i=0; i<nb_write_unit; i++)
195    size_execute_queue [i] = atoi(argv[x++]);
196 
197  uint32_t * nb_bypass_write    = new uint32_t [nb_write_unit];
198  for (uint32_t i=0; i<nb_write_unit; i++)
199    nb_bypass_write    [i] = atoi(argv[x++]);
200
201  multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t * write_queue_scheme    = new multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t [nb_write_unit];
202  for (uint32_t i=0; i<nb_write_unit; i++)
203    write_queue_scheme    [i] = fromString<multi_write_unit::write_unit::write_queue::Twrite_queue_scheme_t>(argv[x++]);
204
205  uint32_t nb_gpr_bank                = atoi(argv[x++]);
206  uint32_t nb_gpr_port_read_by_bank   = atoi(argv[x++]);
207  uint32_t nb_gpr_port_write_by_bank  = atoi(argv[x++]);
208  uint32_t nb_spr_bank                = atoi(argv[x++]);
209  uint32_t nb_spr_port_read_by_bank   = atoi(argv[x++]);
210  uint32_t nb_spr_port_write_by_bank  = atoi(argv[x++]);
211
212  uint32_t * nb_general_register = new uint32_t [nb_ooo_engine];
213  for (uint32_t i=0; i<nb_ooo_engine; i++)
214    nb_general_register [i] = atoi(argv[x++]);
215
216  uint32_t * nb_special_register = new uint32_t [nb_ooo_engine];
217  for (uint32_t i=0; i<nb_ooo_engine; i++)
218    nb_special_register [i] = atoi(argv[x++]);
219
220  uint32_t * nb_inst_insert_rob  = new uint32_t [nb_ooo_engine];
221  for (uint32_t i=0; i<nb_ooo_engine; i++)
222    nb_inst_insert_rob  [i] = atoi(argv[x++]);
223
224  uint32_t * nb_inst_retire_rob  = new uint32_t [nb_ooo_engine];
225  for (uint32_t i=0; i<nb_ooo_engine; i++)
226    nb_inst_retire_rob  [i] = atoi(argv[x++]);
227
228  Tpriority_t execution_unit_to_write_unit_priority = fromString<Tpriority_t>(argv[x++]);
229
230  bool *** execution_unit_to_write_unit_table_routing = new bool ** [nb_execute_unit];
231  for (uint32_t i=0; i<nb_execute_unit; i++)
232    {
233      uint32_t nb_execute_unit_port = (i<nb_load_store_unit)?nb_inst_memory[i]:nb_inst_functionnal_unit[i-nb_load_store_unit];
234
235      execution_unit_to_write_unit_table_routing [i] = new bool * [nb_execute_unit_port];
236     
237      for (uint32_t j=0; j<nb_execute_unit_port; j++)
238        {
239          execution_unit_to_write_unit_table_routing [i][j] = new bool [nb_write_unit];
240         
241          for (uint32_t k=0; k<nb_write_unit; k++)
242            execution_unit_to_write_unit_table_routing [i][j][k] = atoi(argv[x++]);
243        }
244    }
245
246  bool ** execution_unit_to_write_unit_table_thread = new bool * [nb_write_unit];
247  for (uint32_t i=0; i<nb_write_unit; i++)
248    {
249      execution_unit_to_write_unit_table_thread [i] = new bool [nb_thread];
250      for (uint32_t j=0; j<nb_thread; j++)
251        execution_unit_to_write_unit_table_thread  [i][j] = atoi(argv[x++]);
252    }
253  Tpriority_t read_unit_to_execution_unit_priority  = fromString<Tpriority_t>(argv[x++]);
254
255  bool *** read_unit_to_execution_unit_table_routing = new bool ** [nb_read_unit];
256  for (uint32_t i=0; i<nb_read_unit; i++)
257    {
258      read_unit_to_execution_unit_table_routing [i] = new bool * [nb_execute_unit];
259      for (uint32_t j=0; j<nb_execute_unit; j++)
260        {
261          uint32_t nb_execute_unit_port = (j<nb_load_store_unit)?nb_inst_memory[j]:nb_inst_functionnal_unit[j-nb_load_store_unit];
262          read_unit_to_execution_unit_table_routing [i][j] = new bool [nb_execute_unit_port];
263
264          for (uint32_t k=0; k<nb_execute_unit_port; k++)
265            read_unit_to_execution_unit_table_routing [i][j][k] = atoi(argv[x++]);
266        }
267    }
268
269  bool ** read_unit_to_execution_unit_table_thread = new bool * [nb_execute_unit];
270  for (uint32_t i=0; i<nb_execute_unit; i++)
271    {
272      read_unit_to_execution_unit_table_thread [i] = new bool [nb_thread];
273      for (uint32_t j=0; j<nb_thread; j++)
274        read_unit_to_execution_unit_table_thread [i][j] =  atoi(argv[x++]);
275    }
276
277  bool * is_load_store_unit = new bool [nb_execute_unit];
278  for (uint32_t i=0; i<nb_execute_unit; i++)
279    is_load_store_unit [i] = fromString<bool>(argv[x++]);
280
281  uint32_t * translate_num_execute_unit = new uint32_t [nb_execute_unit];
282  for (uint32_t i=0; i<nb_execute_unit; i++)
283    translate_num_execute_unit [i] = fromString<uint32_t>(argv[x++]);
284
285  execute_timing_t *** timing = new execute_timing_t ** [nb_functionnal_unit];
286  // alloc and reset timing array
287  for (uint32_t i=0; i< nb_functionnal_unit; i++)
288    {
289      timing [i] = new execute_timing_t * [MAX_TYPE];
290     
291      for (uint32_t j=0; j< MAX_TYPE; j++)
292        {
293          timing [i][j]= new execute_timing_t [MAX_OPERATION];
294         
295          for (uint32_t k=0; k< MAX_OPERATION; k++)
296            timing[i][j][k]._delay = timing[i][j][k]._latence = 0;
297        }
298    }
299 
300  for (uint32_t i=0; i< nb_functionnal_unit; i++)
301    for (uint32_t j=0; j< MAX_TYPE; j++)
302      {
303        if ( (j != TYPE_MEMORY) and
304             not ((i!=0) and ((j == TYPE_SPECIAL) or
305                              (j == TYPE_CUSTOM))))
306          for (uint32_t k=0; k< MAX_OPERATION; k++)
307            timing[i][j][k]._delay = timing[i][j][k]._latence = 1;
308      }
309
310  morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void) = &(morpheo::behavioural::custom::default_get_custom_information);
311
312  bool * num_thread_valid;
313  ALLOC1(num_thread_valid              ,bool, nb_thread);
314  for (uint32_t i=0; i<nb_thread; ++i)
315    num_thread_valid [i] = true;
316
317  int _return = EXIT_SUCCESS;
318  try 
319    {
320      morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters * param = new morpheo::behavioural::core::multi_execute_loop::execute_loop::Parameters
321        (nb_read_unit                                  ,
322         nb_functionnal_unit                           ,
323         nb_load_store_unit                            ,
324         nb_write_unit                                 ,
325         
326         nb_context                                    ,
327         nb_front_end                                  ,
328         nb_ooo_engine                                 ,
329         nb_packet                                     ,
330         size_general_data                             ,
331         size_special_data                             ,
332         
333         size_read_queue                               ,
334         size_reservation_station                      ,
335         nb_inst_retire                                ,
336
337         nb_inst_functionnal_unit                      ,
338         timing                                        ,
339         get_custom_information                        ,
340                               
341         size_store_queue                              ,
342         size_load_queue                               ,
343         size_speculative_access_queue                 ,
344         nb_port_check                                 ,
345         speculative_load                              ,
346         nb_bypass_memory                              ,
347         nb_cache_port                                 ,
348         nb_inst_memory                                ,
349
350         size_write_queue                              ,
351         size_execute_queue                            ,
352         nb_bypass_write                               ,
353         write_queue_scheme                            ,
354         
355         nb_gpr_bank                                   ,
356         nb_gpr_port_read_by_bank                      ,
357         nb_gpr_port_write_by_bank                     ,
358         nb_spr_bank                                   ,
359         nb_spr_port_read_by_bank                      ,
360         nb_spr_port_write_by_bank                     ,
361         nb_general_register                           ,
362         nb_special_register                           ,
363         nb_inst_insert_rob                            ,
364         nb_inst_retire_rob                            ,
365         
366         execution_unit_to_write_unit_priority         ,
367         execution_unit_to_write_unit_table_routing    ,
368         execution_unit_to_write_unit_table_thread     ,
369         
370         read_unit_to_execution_unit_priority          ,
371         read_unit_to_execution_unit_table_routing     ,
372         read_unit_to_execution_unit_table_thread      ,
373
374         is_load_store_unit                            , //[nb_execute_unit]
375         translate_num_execute_unit                    , //[nb_execute_unit]
376         num_thread_valid                              , //[nb_thread]
377         true // is_toplevel
378         );
379     
380      test (name,param);
381
382      delete param;
383    }
384  catch (morpheo::ErrorMorpheo & error)
385    {
386      msg (_("<%s> :\n%s"),name.c_str(), error.what ());
387      _return = EXIT_FAILURE;
388    }
389
390  try 
391    {
392      if (_return == EXIT_SUCCESS)
393        TEST_OK("OOO_Engine : no error");
394      else
395        TEST_KO("OOO_Engine : a lot of error");
396    }
397  catch (morpheo::ErrorMorpheo & error)
398    {
399//       msg (_("<%s> :\n%s"),name.c_str(), error.what ());
400      _return = EXIT_FAILURE;
401    }
402
403  for (uint32_t i=0; i< nb_functionnal_unit; i++)
404    {
405  for (uint32_t j=0; j< MAX_TYPE; j++)
406  delete [] timing [i][j];
407  delete [] timing [i];
408    }
409  delete [] timing;
410
411  DELETE1(translate_num_execute_unit    ,_nb_execute_unit);
412  DELETE1(is_load_store_unit            ,_nb_execute_unit);
413
414  for (uint32_t i=0; i<nb_execute_unit; i++)
415  delete    read_unit_to_execution_unit_table_thread [i];
416  delete [] read_unit_to_execution_unit_table_thread;
417
418  for (uint32_t i=0; i<nb_read_unit; i++)
419    {
420  for (uint32_t j=0; j<nb_execute_unit; j++)
421  delete [] read_unit_to_execution_unit_table_routing [i][j];
422  delete [] read_unit_to_execution_unit_table_routing [i];
423   }
424  delete [] read_unit_to_execution_unit_table_routing;
425
426  for (uint32_t i=0; i<nb_write_unit; i++)
427  delete    execution_unit_to_write_unit_table_thread [i];
428  delete [] execution_unit_to_write_unit_table_thread;
429
430  for (uint32_t i=0; i<nb_execute_unit; i++)
431    {
432      uint32_t nb_execute_unit_port = (i<nb_load_store_unit)?nb_inst_memory[i]:nb_inst_functionnal_unit[i-nb_load_store_unit];
433  for (uint32_t j=0; j<nb_execute_unit_port; j++)
434  delete [] execution_unit_to_write_unit_table_routing [i][j];
435  delete [] execution_unit_to_write_unit_table_routing [i];
436   }
437  delete [] execution_unit_to_write_unit_table_routing;
438
439  DELETE1(nb_inst_retire_rob            ,_nb_ooo_engine);
440  DELETE1(nb_inst_insert_rob            ,_nb_ooo_engine);
441  DELETE1(nb_special_register           ,_nb_ooo_engine);
442  DELETE1(nb_general_register           ,_nb_ooo_engine);
443  DELETE1(write_queue_scheme            ,_nb_write_unit);
444  DELETE1(nb_bypass_write               ,_nb_write_unit);
445  DELETE1(size_execute_queue            ,_nb_write_unit);
446  DELETE1(size_write_queue              ,_nb_write_unit);
447  DELETE1(nb_inst_memory                ,_nb_load_store_unit);
448  DELETE1(nb_cache_port                 ,_nb_load_store_unit);
449  DELETE1(nb_bypass_memory              ,_nb_load_store_unit);
450  DELETE1(speculative_load              ,_nb_load_store_unit);
451  DELETE1(nb_port_check                 ,_nb_load_store_unit);
452  DELETE1(size_speculative_access_queue ,_nb_load_store_unit);
453  DELETE1(size_load_queue               ,_nb_load_store_unit);
454  DELETE1(size_store_queue              ,_nb_load_store_unit);
455  DELETE1(nb_inst_functionnal_unit      ,_nb_functionnal_unit);
456  DELETE1(nb_inst_retire                ,_nb_read_unit);
457  DELETE1(size_reservation_station      ,_nb_read_unit);
458  DELETE1(size_read_queue               ,_nb_read_unit);
459  DELETE1(num_thread_valid              , nb_thread);
460
461  return (_return);
462}
463
Note: See TracBrowser for help on using the repository browser.