source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/src/test.cpp @ 88

Last change on this file since 88 was 88, checked in by rosiere, 16 years ago

Almost complete design
with Test and test platform
  • Property svn:keywords set to Id
File size: 48.8 KB
Line 
1/*
2 * $Id: test.cpp 88 2008-12-10 18:31:39Z rosiere $
3 *
4 * [ Description ]
5 *
6 * Test
7 */
8
9#define NB_ITERATION  128
10#define CYCLE_MAX     (128*NB_ITERATION)
11
12#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/include/test.h"
13#include "Common/include/Test.h"
14
15void test (string name,
16           morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters * _param)
17{
18  cout << "<" << name << "> : Simulation SystemC" << endl;
19
20#ifdef STATISTICS
21  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
22#endif
23
24  Tusage_t _usage = USE_ALL;
25
26//   _usage = usage_unset(_usage,USE_SYSTEMC              );
27//   _usage = usage_unset(_usage,USE_VHDL                 );
28//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
29//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
30//   _usage = usage_unset(_usage,USE_POSITION             );
31   _usage = usage_unset(_usage,USE_STATISTICS           );
32//   _usage = usage_unset(_usage,USE_INFORMATION          );
33
34  Register_unit_Glue * _Register_unit_Glue = new Register_unit_Glue
35    (name.c_str(),
36#ifdef STATISTICS
37     _parameters_statistics,
38#endif
39     _param,
40     _usage);
41 
42#ifdef SYSTEMC
43  /*********************************************************************
44   * Déclarations des signaux
45   *********************************************************************/
46  sc_clock                         *  in_CLOCK;
47  sc_signal<Tcontrol_t>            *  in_NRESET;
48  sc_signal<Tcontrol_t>            * out_CONST_0;
49  sc_signal<Tcontrol_t>            * out_CONST_1;
50
51  sc_signal<Tcontrol_t        >   **  in_GPR_READ_VAL              ;
52  sc_signal<Tcontrol_t        >   ** out_GPR_READ_ACK              ;
53  sc_signal<Tcontext_t        >   **  in_GPR_READ_OOO_ENGINE_ID    ;
54  sc_signal<Tgeneral_data_t   >   ** out_GPR_READ_DATA             ;
55  sc_signal<Tcontrol_t        >   ** out_GPR_READ_DATA_VAL         ;
56  sc_signal<Tcontrol_t        >  *** out_GPR_READ_REGISTERFILE_VAL ;
57  sc_signal<Tcontrol_t        >  ***  in_GPR_READ_REGISTERFILE_ACK ;
58  sc_signal<Tgeneral_data_t   >  ***  in_GPR_READ_REGISTERFILE_DATA;
59  sc_signal<Tcontrol_t        >  *** out_GPR_READ_STATUS_VAL       ;
60  sc_signal<Tcontrol_t        >  ***  in_GPR_READ_STATUS_ACK       ;
61  sc_signal<Tcontrol_t        >  ***  in_GPR_READ_STATUS_DATA_VAL  ;
62
63  sc_signal<Tcontrol_t        >   **  in_SPR_READ_VAL              ;
64  sc_signal<Tcontrol_t        >   ** out_SPR_READ_ACK              ;
65  sc_signal<Tcontext_t        >   **  in_SPR_READ_OOO_ENGINE_ID    ;
66  sc_signal<Tspecial_data_t   >   ** out_SPR_READ_DATA             ;
67  sc_signal<Tcontrol_t        >   ** out_SPR_READ_DATA_VAL         ;
68  sc_signal<Tcontrol_t        >  *** out_SPR_READ_REGISTERFILE_VAL ;
69  sc_signal<Tcontrol_t        >  ***  in_SPR_READ_REGISTERFILE_ACK ;
70  sc_signal<Tspecial_data_t   >  ***  in_SPR_READ_REGISTERFILE_DATA;
71  sc_signal<Tcontrol_t        >  *** out_SPR_READ_STATUS_VAL       ;
72  sc_signal<Tcontrol_t        >  ***  in_SPR_READ_STATUS_ACK       ;
73  sc_signal<Tcontrol_t        >  ***  in_SPR_READ_STATUS_DATA_VAL  ;
74
75  sc_signal<Tcontrol_t        >   **  in_GPR_WRITE_VAL             ;
76  sc_signal<Tcontrol_t        >   ** out_GPR_WRITE_ACK             ;
77  sc_signal<Tcontext_t        >   **  in_GPR_WRITE_OOO_ENGINE_ID   ;
78  sc_signal<Tcontrol_t        >  *** out_GPR_WRITE_REGISTERFILE_VAL;
79  sc_signal<Tcontrol_t        >  ***  in_GPR_WRITE_REGISTERFILE_ACK;
80  sc_signal<Tcontrol_t        >  *** out_GPR_WRITE_STATUS_VAL      ;
81  sc_signal<Tcontrol_t        >  ***  in_GPR_WRITE_STATUS_ACK      ;
82 
83  sc_signal<Tcontrol_t        >   **  in_SPR_WRITE_VAL             ;
84  sc_signal<Tcontrol_t        >   ** out_SPR_WRITE_ACK             ;
85  sc_signal<Tcontext_t        >   **  in_SPR_WRITE_OOO_ENGINE_ID   ;
86  sc_signal<Tcontrol_t        >  *** out_SPR_WRITE_REGISTERFILE_VAL;
87  sc_signal<Tcontrol_t        >  ***  in_SPR_WRITE_REGISTERFILE_ACK;
88  sc_signal<Tcontrol_t        >  *** out_SPR_WRITE_STATUS_VAL      ;
89  sc_signal<Tcontrol_t        >  ***  in_SPR_WRITE_STATUS_ACK      ;
90
91  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_VAL                       ;
92  sc_signal<Tcontrol_t        >  *** out_INSERT_ROB_ACK                       ;
93  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_RD_USE                    ;
94  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_RE_USE                    ;
95  sc_signal<Tcontrol_t        >  *** out_INSERT_ROB_GPR_STATUS_VAL            ;
96  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_GPR_STATUS_ACK            ;
97  sc_signal<Tcontrol_t        >  *** out_INSERT_ROB_SPR_STATUS_VAL            ;
98  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_SPR_STATUS_ACK            ;
99
100//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL                       ;
101//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK                       ;
102//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE                ;
103//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE                ;
104//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE                ;
105//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE                ;
106//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL        ;
107//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_NEW_ACK        ;
108//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL        ;
109//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_GPR_STATUS_OLD_ACK        ;
110//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL        ;
111//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_NEW_ACK        ;
112//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL        ;
113//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_SPR_STATUS_OLD_ACK        ;
114
115  string rename;
116
117   in_CLOCK                               = new sc_clock ("clock", 1.0, 0.5);
118   in_NRESET                              = new sc_signal<Tcontrol_t> ("NRESET");
119  out_CONST_0                             = new sc_signal<Tcontrol_t> ("CONST_0");
120  out_CONST_1                             = new sc_signal<Tcontrol_t> ("CONST_1");
121
122    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
123   in_GPR_READ_VAL               = new sc_signal<Tcontrol_t     >   * [_param->_nb_gpr_read];
124  out_GPR_READ_ACK               = new sc_signal<Tcontrol_t     >   * [_param->_nb_gpr_read];
125   in_GPR_READ_OOO_ENGINE_ID     = new sc_signal<Tcontext_t     >   * [_param->_nb_gpr_read];
126  out_GPR_READ_DATA              = new sc_signal<Tgeneral_data_t>   * [_param->_nb_gpr_read];
127  out_GPR_READ_DATA_VAL          = new sc_signal<Tcontrol_t     >   * [_param->_nb_gpr_read];
128  out_GPR_READ_REGISTERFILE_VAL  = new sc_signal<Tcontrol_t     >  ** [_param->_nb_ooo_engine];
129   in_GPR_READ_REGISTERFILE_ACK  = new sc_signal<Tcontrol_t     >  ** [_param->_nb_ooo_engine];
130   in_GPR_READ_REGISTERFILE_DATA = new sc_signal<Tgeneral_data_t>  ** [_param->_nb_ooo_engine];
131  out_GPR_READ_STATUS_VAL        = new sc_signal<Tcontrol_t     >  ** [_param->_nb_ooo_engine];
132   in_GPR_READ_STATUS_ACK        = new sc_signal<Tcontrol_t     >  ** [_param->_nb_ooo_engine];
133   in_GPR_READ_STATUS_DATA_VAL   = new sc_signal<Tcontrol_t     >  ** [_param->_nb_ooo_engine];
134
135   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
136     {
137       out_GPR_READ_REGISTERFILE_VAL  [i] = new sc_signal<Tcontrol_t     >  * [_param->_nb_gpr_read];
138        in_GPR_READ_REGISTERFILE_ACK  [i] = new sc_signal<Tcontrol_t     >  * [_param->_nb_gpr_read];
139        in_GPR_READ_REGISTERFILE_DATA [i] = new sc_signal<Tgeneral_data_t>  * [_param->_nb_gpr_read];
140       out_GPR_READ_STATUS_VAL        [i] = new sc_signal<Tcontrol_t     >  * [_param->_nb_gpr_read];
141        in_GPR_READ_STATUS_ACK        [i] = new sc_signal<Tcontrol_t     >  * [_param->_nb_gpr_read];
142        in_GPR_READ_STATUS_DATA_VAL   [i] = new sc_signal<Tcontrol_t     >  * [_param->_nb_gpr_read];
143     }
144
145   for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
146     {
147        in_GPR_READ_VAL           [j] =  new sc_signal<Tcontrol_t     > (rename.c_str());
148       out_GPR_READ_ACK           [j] =  new sc_signal<Tcontrol_t     > (rename.c_str());
149        in_GPR_READ_OOO_ENGINE_ID [j] =  new sc_signal<Tcontext_t     > (rename.c_str());
150       out_GPR_READ_DATA          [j] =  new sc_signal<Tgeneral_data_t> (rename.c_str());
151       out_GPR_READ_DATA_VAL      [j] =  new sc_signal<Tcontrol_t     > (rename.c_str());
152
153       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
154         {
155             out_GPR_READ_REGISTERFILE_VAL  [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
156              in_GPR_READ_REGISTERFILE_ACK  [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
157              in_GPR_READ_REGISTERFILE_DATA [i][j] = new sc_signal<Tgeneral_data_t> (rename.c_str());
158             out_GPR_READ_STATUS_VAL        [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
159              in_GPR_READ_STATUS_ACK        [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
160              in_GPR_READ_STATUS_DATA_VAL   [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
161         }
162     }
163
164    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
165   in_SPR_READ_VAL               = new sc_signal<Tcontrol_t     >  * [_param->_nb_spr_read];
166  out_SPR_READ_ACK               = new sc_signal<Tcontrol_t     >  * [_param->_nb_spr_read];
167   in_SPR_READ_OOO_ENGINE_ID     = new sc_signal<Tcontext_t     >  * [_param->_nb_spr_read];
168  out_SPR_READ_DATA              = new sc_signal<Tspecial_data_t>  * [_param->_nb_spr_read];
169  out_SPR_READ_DATA_VAL          = new sc_signal<Tcontrol_t     >  * [_param->_nb_spr_read];
170  out_SPR_READ_REGISTERFILE_VAL  = new sc_signal<Tcontrol_t     > ** [_param->_nb_ooo_engine];
171   in_SPR_READ_REGISTERFILE_ACK  = new sc_signal<Tcontrol_t     > ** [_param->_nb_ooo_engine];
172   in_SPR_READ_REGISTERFILE_DATA = new sc_signal<Tspecial_data_t> ** [_param->_nb_ooo_engine];
173  out_SPR_READ_STATUS_VAL        = new sc_signal<Tcontrol_t     > ** [_param->_nb_ooo_engine];
174   in_SPR_READ_STATUS_ACK        = new sc_signal<Tcontrol_t     > ** [_param->_nb_ooo_engine];
175   in_SPR_READ_STATUS_DATA_VAL   = new sc_signal<Tcontrol_t     > ** [_param->_nb_ooo_engine];
176
177   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
178     {
179       out_SPR_READ_REGISTERFILE_VAL  [i] = new sc_signal<Tcontrol_t     > * [_param->_nb_spr_read];
180        in_SPR_READ_REGISTERFILE_ACK  [i] = new sc_signal<Tcontrol_t     > * [_param->_nb_spr_read];
181        in_SPR_READ_REGISTERFILE_DATA [i] = new sc_signal<Tspecial_data_t> * [_param->_nb_spr_read];
182       out_SPR_READ_STATUS_VAL        [i] = new sc_signal<Tcontrol_t     > * [_param->_nb_spr_read];
183        in_SPR_READ_STATUS_ACK        [i] = new sc_signal<Tcontrol_t     > * [_param->_nb_spr_read];
184        in_SPR_READ_STATUS_DATA_VAL   [i] = new sc_signal<Tcontrol_t     > * [_param->_nb_spr_read];
185     }
186
187   for (uint32_t j=0; j<_param->_nb_spr_read; j++)
188     {
189        in_SPR_READ_VAL           [j] = new sc_signal<Tcontrol_t     > (rename.c_str());
190       out_SPR_READ_ACK           [j] = new sc_signal<Tcontrol_t     > (rename.c_str());
191        in_SPR_READ_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t     > (rename.c_str());
192       out_SPR_READ_DATA          [j] = new sc_signal<Tspecial_data_t> (rename.c_str());
193       out_SPR_READ_DATA_VAL      [j] = new sc_signal<Tcontrol_t     > (rename.c_str());
194
195       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
196         {
197             out_SPR_READ_REGISTERFILE_VAL  [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
198              in_SPR_READ_REGISTERFILE_ACK  [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
199              in_SPR_READ_REGISTERFILE_DATA [i][j] = new sc_signal<Tspecial_data_t> (rename.c_str());
200             out_SPR_READ_STATUS_VAL        [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
201              in_SPR_READ_STATUS_ACK        [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
202              in_SPR_READ_STATUS_DATA_VAL   [i][j] = new sc_signal<Tcontrol_t     > (rename.c_str());
203         }
204     }
205
206    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
207   in_GPR_WRITE_VAL               = new sc_signal<Tcontrol_t>  * [_param->_nb_gpr_write];
208  out_GPR_WRITE_ACK               = new sc_signal<Tcontrol_t>  * [_param->_nb_gpr_write];
209   in_GPR_WRITE_OOO_ENGINE_ID     = new sc_signal<Tcontext_t>  * [_param->_nb_gpr_write];
210  out_GPR_WRITE_REGISTERFILE_VAL  = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
211   in_GPR_WRITE_REGISTERFILE_ACK  = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
212  out_GPR_WRITE_STATUS_VAL        = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
213   in_GPR_WRITE_STATUS_ACK        = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
214
215   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
216     {
217       out_GPR_WRITE_REGISTERFILE_VAL  [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
218        in_GPR_WRITE_REGISTERFILE_ACK  [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
219       out_GPR_WRITE_STATUS_VAL        [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
220        in_GPR_WRITE_STATUS_ACK        [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
221     }
222
223   for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
224     {
225        in_GPR_WRITE_VAL           [j] = new sc_signal<Tcontrol_t> (rename.c_str());
226       out_GPR_WRITE_ACK           [j] = new sc_signal<Tcontrol_t> (rename.c_str());
227        in_GPR_WRITE_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t> (rename.c_str());
228
229       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
230         {
231             out_GPR_WRITE_REGISTERFILE_VAL  [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
232              in_GPR_WRITE_REGISTERFILE_ACK  [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
233             out_GPR_WRITE_STATUS_VAL        [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
234              in_GPR_WRITE_STATUS_ACK        [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
235         }
236     }
237
238    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
239   in_SPR_WRITE_VAL               = new sc_signal<Tcontrol_t>   * [_param->_nb_spr_write];
240  out_SPR_WRITE_ACK               = new sc_signal<Tcontrol_t>   * [_param->_nb_spr_write];
241   in_SPR_WRITE_OOO_ENGINE_ID     = new sc_signal<Tcontext_t>   * [_param->_nb_spr_write];
242  out_SPR_WRITE_REGISTERFILE_VAL  = new sc_signal<Tcontrol_t>  ** [_param->_nb_ooo_engine];
243   in_SPR_WRITE_REGISTERFILE_ACK  = new sc_signal<Tcontrol_t>  ** [_param->_nb_ooo_engine];
244  out_SPR_WRITE_STATUS_VAL        = new sc_signal<Tcontrol_t>  ** [_param->_nb_ooo_engine];
245   in_SPR_WRITE_STATUS_ACK        = new sc_signal<Tcontrol_t>  ** [_param->_nb_ooo_engine];
246
247   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
248     {
249       out_SPR_WRITE_REGISTERFILE_VAL  [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
250        in_SPR_WRITE_REGISTERFILE_ACK  [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
251       out_SPR_WRITE_STATUS_VAL        [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
252        in_SPR_WRITE_STATUS_ACK        [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
253     }
254
255   for (uint32_t j=0; j<_param->_nb_spr_write; j++)
256     {
257        in_SPR_WRITE_VAL           [j] = new sc_signal<Tcontrol_t> (rename.c_str());
258       out_SPR_WRITE_ACK           [j] = new sc_signal<Tcontrol_t> (rename.c_str());
259        in_SPR_WRITE_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t> (rename.c_str());
260
261       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
262         {
263             out_SPR_WRITE_REGISTERFILE_VAL  [i][j] = new sc_signal<Tcontrol_t>  (rename.c_str());
264              in_SPR_WRITE_REGISTERFILE_ACK  [i][j] = new sc_signal<Tcontrol_t>  (rename.c_str());
265             out_SPR_WRITE_STATUS_VAL        [i][j] = new sc_signal<Tcontrol_t>  (rename.c_str());
266              in_SPR_WRITE_STATUS_ACK        [i][j] = new sc_signal<Tcontrol_t>  (rename.c_str());
267         }
268     }
269
270   // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
271    in_INSERT_ROB_VAL                  = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
272   out_INSERT_ROB_ACK                  = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
273    in_INSERT_ROB_RD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
274    in_INSERT_ROB_RE_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
275   out_INSERT_ROB_GPR_STATUS_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
276    in_INSERT_ROB_GPR_STATUS_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
277   out_INSERT_ROB_SPR_STATUS_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
278    in_INSERT_ROB_SPR_STATUS_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
279
280    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
281      {
282        uint32_t x=_param->_nb_inst_insert_rob [i];
283
284        in_INSERT_ROB_VAL                  [i] = new sc_signal<Tcontrol_t> * [x];
285       out_INSERT_ROB_ACK                  [i] = new sc_signal<Tcontrol_t> * [x];
286        in_INSERT_ROB_RD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
287        in_INSERT_ROB_RE_USE               [i] = new sc_signal<Tcontrol_t> * [x];
288       out_INSERT_ROB_GPR_STATUS_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
289        in_INSERT_ROB_GPR_STATUS_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
290       out_INSERT_ROB_SPR_STATUS_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
291        in_INSERT_ROB_SPR_STATUS_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
292
293        for (uint32_t j=0; j<x; j++)
294          {
295               in_INSERT_ROB_VAL                  [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
296              out_INSERT_ROB_ACK                  [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
297               in_INSERT_ROB_RD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
298               in_INSERT_ROB_RE_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
299              out_INSERT_ROB_GPR_STATUS_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
300               in_INSERT_ROB_GPR_STATUS_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
301              out_INSERT_ROB_SPR_STATUS_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
302               in_INSERT_ROB_SPR_STATUS_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
303          }
304      }
305
306//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
307//     in_RETIRE_ROB_VAL                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
308//    out_RETIRE_ROB_ACK                      = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
309//     in_RETIRE_ROB_RD_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
310//     in_RETIRE_ROB_RD_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
311//     in_RETIRE_ROB_RE_OLD_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
312//     in_RETIRE_ROB_RE_NEW_USE               = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
313//    out_RETIRE_ROB_GPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
314//    out_RETIRE_ROB_GPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
315//     in_RETIRE_ROB_GPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
316//     in_RETIRE_ROB_GPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
317//    out_RETIRE_ROB_SPR_STATUS_OLD_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
318//    out_RETIRE_ROB_SPR_STATUS_NEW_VAL       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
319//     in_RETIRE_ROB_SPR_STATUS_OLD_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
320//     in_RETIRE_ROB_SPR_STATUS_NEW_ACK       = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
321
322//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
323//       {
324//      uint32_t x=_param->_nb_inst_retire_rob [i];
325
326//       in_RETIRE_ROB_VAL                      [i] = new sc_signal<Tcontrol_t> * [x];
327//      out_RETIRE_ROB_ACK                      [i] = new sc_signal<Tcontrol_t> * [x];
328//       in_RETIRE_ROB_RD_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
329//       in_RETIRE_ROB_RD_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
330//       in_RETIRE_ROB_RE_OLD_USE               [i] = new sc_signal<Tcontrol_t> * [x];
331//       in_RETIRE_ROB_RE_NEW_USE               [i] = new sc_signal<Tcontrol_t> * [x];
332//      out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
333//      out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
334//       in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
335//       in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
336//      out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
337//      out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i] = new sc_signal<Tcontrol_t> * [x];
338//       in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
339//       in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i] = new sc_signal<Tcontrol_t> * [x];
340   
341//      for (uint32_t j=0; j<x; j++)
342//        {
343//             in_RETIRE_ROB_VAL                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
344//            out_RETIRE_ROB_ACK                      [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
345//             in_RETIRE_ROB_RD_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
346//             in_RETIRE_ROB_RD_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
347//             in_RETIRE_ROB_RE_OLD_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
348//             in_RETIRE_ROB_RE_NEW_USE               [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
349//            out_RETIRE_ROB_GPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
350//             in_RETIRE_ROB_GPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
351//            out_RETIRE_ROB_GPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
352//             in_RETIRE_ROB_GPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
353//            out_RETIRE_ROB_SPR_STATUS_OLD_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
354//             in_RETIRE_ROB_SPR_STATUS_OLD_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
355//            out_RETIRE_ROB_SPR_STATUS_NEW_VAL       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
356//             in_RETIRE_ROB_SPR_STATUS_NEW_ACK       [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
357//          }
358//       }
359   
360
361 
362  /********************************************************
363   * Instanciation
364   ********************************************************/
365 
366  cout << "<" << name << "> Instanciation of _Register_unit_Glue" << endl;
367 
368  (*(_Register_unit_Glue-> in_CLOCK  ))       (*( in_CLOCK  ));
369  (*(_Register_unit_Glue-> in_NRESET ))       (*( in_NRESET ));
370  (*(_Register_unit_Glue->out_CONST_0))       (*(out_CONST_0));
371  (*(_Register_unit_Glue->out_CONST_1))       (*(out_CONST_1));
372
373   for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
374     {
375       (*(_Register_unit_Glue-> in_GPR_READ_VAL           [j]))(*( in_GPR_READ_VAL           [j]));
376       (*(_Register_unit_Glue->out_GPR_READ_ACK           [j]))(*(out_GPR_READ_ACK           [j]));
377       if (_param->_have_port_ooo_engine_id == true)
378       (*(_Register_unit_Glue-> in_GPR_READ_OOO_ENGINE_ID [j]))(*( in_GPR_READ_OOO_ENGINE_ID [j]));
379       (*(_Register_unit_Glue->out_GPR_READ_DATA          [j]))(*(out_GPR_READ_DATA          [j]));
380       (*(_Register_unit_Glue->out_GPR_READ_DATA_VAL      [j]))(*(out_GPR_READ_DATA_VAL      [j]));
381
382       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
383         {
384           (*(_Register_unit_Glue->out_GPR_READ_REGISTERFILE_VAL  [i][j]))(*(out_GPR_READ_REGISTERFILE_VAL  [i][j]));
385           (*(_Register_unit_Glue-> in_GPR_READ_REGISTERFILE_ACK  [i][j]))(*( in_GPR_READ_REGISTERFILE_ACK  [i][j]));
386           (*(_Register_unit_Glue-> in_GPR_READ_REGISTERFILE_DATA [i][j]))(*( in_GPR_READ_REGISTERFILE_DATA [i][j]));
387           (*(_Register_unit_Glue->out_GPR_READ_STATUS_VAL        [i][j]))(*(out_GPR_READ_STATUS_VAL        [i][j]));
388           (*(_Register_unit_Glue-> in_GPR_READ_STATUS_ACK        [i][j]))(*( in_GPR_READ_STATUS_ACK        [i][j]));
389           (*(_Register_unit_Glue-> in_GPR_READ_STATUS_DATA_VAL   [i][j]))(*( in_GPR_READ_STATUS_DATA_VAL   [i][j]));
390         }
391     }
392
393   for (uint32_t j=0; j<_param->_nb_spr_read; j++)
394     {
395       (*(_Register_unit_Glue-> in_SPR_READ_VAL           [j]))(*( in_SPR_READ_VAL           [j]));
396       (*(_Register_unit_Glue->out_SPR_READ_ACK           [j]))(*(out_SPR_READ_ACK           [j]));
397       if (_param->_have_port_ooo_engine_id == true)
398       (*(_Register_unit_Glue-> in_SPR_READ_OOO_ENGINE_ID [j]))(*( in_SPR_READ_OOO_ENGINE_ID [j]));
399       (*(_Register_unit_Glue->out_SPR_READ_DATA          [j]))(*(out_SPR_READ_DATA          [j]));
400       (*(_Register_unit_Glue->out_SPR_READ_DATA_VAL      [j]))(*(out_SPR_READ_DATA_VAL      [j]));
401
402       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
403         {
404           (*(_Register_unit_Glue->out_SPR_READ_REGISTERFILE_VAL  [i][j]))(*(out_SPR_READ_REGISTERFILE_VAL  [i][j]));
405           (*(_Register_unit_Glue-> in_SPR_READ_REGISTERFILE_ACK  [i][j]))(*( in_SPR_READ_REGISTERFILE_ACK  [i][j]));
406           (*(_Register_unit_Glue-> in_SPR_READ_REGISTERFILE_DATA [i][j]))(*( in_SPR_READ_REGISTERFILE_DATA [i][j]));
407           (*(_Register_unit_Glue->out_SPR_READ_STATUS_VAL        [i][j]))(*(out_SPR_READ_STATUS_VAL        [i][j]));
408           (*(_Register_unit_Glue-> in_SPR_READ_STATUS_ACK        [i][j]))(*( in_SPR_READ_STATUS_ACK        [i][j]));
409           (*(_Register_unit_Glue-> in_SPR_READ_STATUS_DATA_VAL   [i][j]))(*( in_SPR_READ_STATUS_DATA_VAL   [i][j]));
410         }
411     }
412
413   for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
414     {
415       (*(_Register_unit_Glue-> in_GPR_WRITE_VAL           [j]))(*( in_GPR_WRITE_VAL           [j]));
416       (*(_Register_unit_Glue->out_GPR_WRITE_ACK           [j]))(*(out_GPR_WRITE_ACK           [j]));
417       if (_param->_have_port_ooo_engine_id == true)
418       (*(_Register_unit_Glue-> in_GPR_WRITE_OOO_ENGINE_ID [j]))(*( in_GPR_WRITE_OOO_ENGINE_ID [j]));
419
420       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
421         {
422           (*(_Register_unit_Glue->out_GPR_WRITE_REGISTERFILE_VAL  [i][j]))(*(out_GPR_WRITE_REGISTERFILE_VAL  [i][j]));
423           (*(_Register_unit_Glue-> in_GPR_WRITE_REGISTERFILE_ACK  [i][j]))(*( in_GPR_WRITE_REGISTERFILE_ACK  [i][j]));
424           (*(_Register_unit_Glue->out_GPR_WRITE_STATUS_VAL        [i][j]))(*(out_GPR_WRITE_STATUS_VAL        [i][j]));
425           (*(_Register_unit_Glue-> in_GPR_WRITE_STATUS_ACK        [i][j]))(*( in_GPR_WRITE_STATUS_ACK        [i][j]));
426         }
427     }
428
429   for (uint32_t j=0; j<_param->_nb_spr_write; j++)
430     {
431       (*(_Register_unit_Glue-> in_SPR_WRITE_VAL           [j]))(*( in_SPR_WRITE_VAL           [j]));
432       (*(_Register_unit_Glue->out_SPR_WRITE_ACK           [j]))(*(out_SPR_WRITE_ACK           [j]));
433       if (_param->_have_port_ooo_engine_id == true)
434       (*(_Register_unit_Glue-> in_SPR_WRITE_OOO_ENGINE_ID [j]))(*( in_SPR_WRITE_OOO_ENGINE_ID [j]));
435
436       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
437         {
438           (*(_Register_unit_Glue->out_SPR_WRITE_REGISTERFILE_VAL  [i][j]))(*(out_SPR_WRITE_REGISTERFILE_VAL  [i][j]));
439           (*(_Register_unit_Glue-> in_SPR_WRITE_REGISTERFILE_ACK  [i][j]))(*( in_SPR_WRITE_REGISTERFILE_ACK  [i][j]));
440           (*(_Register_unit_Glue->out_SPR_WRITE_STATUS_VAL        [i][j]))(*(out_SPR_WRITE_STATUS_VAL        [i][j]));
441           (*(_Register_unit_Glue-> in_SPR_WRITE_STATUS_ACK        [i][j]))(*( in_SPR_WRITE_STATUS_ACK        [i][j]));
442         }
443     }
444
445   // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
446    for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
447      {
448        uint32_t x=_param->_nb_inst_insert_rob [i];
449
450        for (uint32_t j=0; j<x; j++)
451          {
452            (*(_Register_unit_Glue-> in_INSERT_ROB_VAL            [i][j]))  (*( in_INSERT_ROB_VAL            [i][j]));
453            (*(_Register_unit_Glue->out_INSERT_ROB_ACK            [i][j]))  (*(out_INSERT_ROB_ACK            [i][j]));
454            (*(_Register_unit_Glue-> in_INSERT_ROB_RD_USE         [i][j]))  (*( in_INSERT_ROB_RD_USE         [i][j]));
455            (*(_Register_unit_Glue-> in_INSERT_ROB_RE_USE         [i][j]))  (*( in_INSERT_ROB_RE_USE         [i][j]));
456            (*(_Register_unit_Glue->out_INSERT_ROB_GPR_STATUS_VAL [i][j]))  (*(out_INSERT_ROB_GPR_STATUS_VAL [i][j]));
457            (*(_Register_unit_Glue-> in_INSERT_ROB_GPR_STATUS_ACK [i][j]))  (*( in_INSERT_ROB_GPR_STATUS_ACK [i][j]));
458            (*(_Register_unit_Glue->out_INSERT_ROB_SPR_STATUS_VAL [i][j]))  (*(out_INSERT_ROB_SPR_STATUS_VAL [i][j]));
459            (*(_Register_unit_Glue-> in_INSERT_ROB_SPR_STATUS_ACK [i][j]))  (*( in_INSERT_ROB_SPR_STATUS_ACK [i][j]));
460          }
461      }
462
463//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
464
465//     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
466//       {
467//      uint32_t x=_param->_nb_inst_retire_rob [i];
468
469//      for (uint32_t j=0; j<x; j++)
470//        {
471//          (*(_Register_unit_Glue-> in_RETIRE_ROB_VAL                [i][j]))(*( in_RETIRE_ROB_VAL                [i][j]));
472//          (*(_Register_unit_Glue->out_RETIRE_ROB_ACK                [i][j]))(*(out_RETIRE_ROB_ACK                [i][j]));
473//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE         [i][j]));
474//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RD_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE         [i][j]));
475//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_OLD_USE         [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE         [i][j]));
476//          (*(_Register_unit_Glue-> in_RETIRE_ROB_RE_NEW_USE         [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE         [i][j]));
477//          (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]));
478//          (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
479//          (*(_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]));
480//          (*(_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
481//          (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]));
482//          (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
483//          (*(_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))(*(out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]));
484//          (*(_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]))(*( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
485//          }
486//       }
487   
488  cout << "<" << name << "> Start Simulation ............" << endl;
489  Time * _time = new Time();
490
491  /********************************************************
492   * Simulation - Begin
493   ********************************************************/
494
495  // Initialisation
496  const bool     test_read   = true;
497  const bool     test_write  = true;
498  const bool     test_insert = true;
499//   const bool     test_retire = true;
500
501  const  int32_t percent_transaction = 75;
502
503  const uint32_t seed = 0;
504//const uint32_t seed = static_cast<uint32_t>(time(NULL));
505
506  srand(seed);
507
508  Tcontext_t      context;
509  Tcontrol_t      gpr_read_ack              [_param->_nb_gpr_read];
510  Tgeneral_data_t gpr_read_data             [_param->_nb_gpr_read];
511  Tcontrol_t      gpr_read_data_val         [_param->_nb_gpr_read];
512  Tcontrol_t      gpr_read_registerfile_val [_param->_nb_ooo_engine][_param->_nb_gpr_read];
513  Tcontrol_t      gpr_read_status_val       [_param->_nb_ooo_engine][_param->_nb_gpr_read];
514
515  Tcontrol_t      gpr_write_ack              [_param->_nb_gpr_write];
516  Tcontrol_t      gpr_write_registerfile_val [_param->_nb_ooo_engine][_param->_nb_gpr_write];
517  Tcontrol_t      gpr_write_status_val       [_param->_nb_ooo_engine][_param->_nb_gpr_write];
518
519  Tcontrol_t      spr_read_ack              [_param->_nb_spr_read];
520  Tspecial_data_t spr_read_data             [_param->_nb_spr_read];
521  Tcontrol_t      spr_read_data_val         [_param->_nb_spr_read];
522  Tcontrol_t      spr_read_registerfile_val [_param->_nb_ooo_engine][_param->_nb_spr_read];
523  Tcontrol_t      spr_read_status_val       [_param->_nb_ooo_engine][_param->_nb_spr_read];
524
525  Tcontrol_t      spr_write_ack              [_param->_nb_spr_write];
526  Tcontrol_t      spr_write_registerfile_val [_param->_nb_ooo_engine][_param->_nb_spr_write];
527  Tcontrol_t      spr_write_status_val       [_param->_nb_ooo_engine][_param->_nb_spr_write];
528
529//   uint32_t        max_nb_inst_retire_rob = 0;
530
531//   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
532//     if (_param->_nb_inst_retire_rob [i] > max_nb_inst_retire_rob)
533//       max_nb_inst_retire_rob = _param->_nb_inst_retire_rob [i];
534
535//   Tcontrol_t      retire_rob_ack                [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
536//   Tcontrol_t      retire_rob_gpr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
537//   Tcontrol_t      retire_rob_gpr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
538//   Tcontrol_t      retire_rob_spr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
539//   Tcontrol_t      retire_rob_spr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
540
541  uint32_t        max_nb_inst_insert_rob = 0;
542
543  for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
544    if (_param->_nb_inst_insert_rob [i] > max_nb_inst_insert_rob)
545      max_nb_inst_insert_rob = _param->_nb_inst_insert_rob [i];
546
547  Tcontrol_t      insert_rob_ack            [_param->_nb_ooo_engine][max_nb_inst_insert_rob];
548  Tcontrol_t      insert_rob_gpr_status_val [_param->_nb_ooo_engine][max_nb_inst_insert_rob];
549  Tcontrol_t      insert_rob_spr_status_val [_param->_nb_ooo_engine][max_nb_inst_insert_rob];
550
551  SC_START(0);
552  LABEL("Initialisation");
553
554  in_NRESET->write(0);
555  SC_START(5);
556  in_NRESET->write(1);
557
558  LABEL("Loop of Test");
559
560  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
561    {
562      LABEL("Iteration %d",iteration);
563
564      if (test_read == true)
565        {
566          for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
567            {
568              context = (rand())%_param->_nb_ooo_engine;
569              Tcontrol_t      val = (rand()%100)<=percent_transaction;
570             
571              LABEL("GPR_READ  [%d] : %d - %d",j,val,context);
572             
573              in_GPR_READ_VAL           [j] ->write(val);
574              in_GPR_READ_OOO_ENGINE_ID [j] ->write(context);
575             
576              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
577                {
578                  Tcontrol_t      registerfile_ack  = (rand()%100)<=percent_transaction  ;
579                  Tgeneral_data_t registerfile_data = (rand()%_param->_size_general_data);
580                  Tcontrol_t      status_ack        = (rand()%100)<=percent_transaction  ;
581                  Tcontrol_t      status_data_val   = (rand()%100)<=percent_transaction  ;
582                 
583                  in_GPR_READ_REGISTERFILE_ACK  [i][j]->write(registerfile_ack );
584                  in_GPR_READ_REGISTERFILE_DATA [i][j]->write(registerfile_data);
585                  in_GPR_READ_STATUS_ACK        [i][j]->write(status_ack       );
586                  in_GPR_READ_STATUS_DATA_VAL   [i][j]->write(status_data_val  );
587                 
588                  if (i == context)
589                    {
590                      gpr_read_registerfile_val [i][j] = val and status_ack      ;
591                      gpr_read_status_val       [i][j] = val and registerfile_ack;
592                     
593                      gpr_read_ack      [j] = registerfile_ack and status_ack;
594                      gpr_read_data     [j] = registerfile_data;
595                      gpr_read_data_val [j] = status_data_val;
596                    }
597                  else
598                    {
599                      gpr_read_registerfile_val [i][j] = 0;
600                      gpr_read_status_val       [i][j] = 0;
601                    }
602                }
603            }
604
605          for (uint32_t j=0; j<_param->_nb_spr_read; j++)
606            {
607              context = (rand())%_param->_nb_ooo_engine;
608              Tcontrol_t      val = (rand()%100)<=percent_transaction;
609             
610              LABEL("SPR_READ  [%d] : %d - %d",j,val,context);
611             
612              in_SPR_READ_VAL           [j] ->write(val);
613              in_SPR_READ_OOO_ENGINE_ID [j] ->write(context);
614             
615              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
616                {
617                  Tcontrol_t      registerfile_ack  = (rand()%100)<=percent_transaction  ;
618                  Tspecial_data_t registerfile_data = (rand()%_param->_size_special_data);
619                  Tcontrol_t      status_ack        = (rand()%100)<=percent_transaction  ;
620                  Tcontrol_t      status_data_val   = (rand()%100)<=percent_transaction  ;
621                 
622                  in_SPR_READ_REGISTERFILE_ACK  [i][j]->write(registerfile_ack );
623                  in_SPR_READ_REGISTERFILE_DATA [i][j]->write(registerfile_data);
624                  in_SPR_READ_STATUS_ACK        [i][j]->write(status_ack       );
625                  in_SPR_READ_STATUS_DATA_VAL   [i][j]->write(status_data_val  );
626                 
627                  if (i == context)
628                    {
629                      spr_read_registerfile_val [i][j] = val and status_ack      ;
630                      spr_read_status_val       [i][j] = val and registerfile_ack;
631                     
632                      spr_read_ack      [j] = registerfile_ack and status_ack;
633                      spr_read_data     [j] = registerfile_data;
634                      spr_read_data_val [j] = status_data_val;
635                    }
636                  else
637                    {
638                      spr_read_registerfile_val [i][j] = 0;
639                      spr_read_status_val       [i][j] = 0;
640                    }
641                 
642                }
643            }
644        }
645
646      if (test_write == true)
647        {
648          for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
649            {
650              context = (rand())%_param->_nb_ooo_engine;
651              Tcontrol_t      val = (rand()%100)<=percent_transaction;
652             
653              LABEL("GPR_WRITE [%d] : %d - %d",j,val,context);
654
655              in_GPR_WRITE_VAL           [j] ->write(val);
656              in_GPR_WRITE_OOO_ENGINE_ID [j] ->write(context);
657             
658              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
659                {
660                  Tcontrol_t      registerfile_ack  = (rand()%100)<=percent_transaction  ;
661                  Tcontrol_t      status_ack        = (rand()%100)<=percent_transaction  ;
662                 
663                  in_GPR_WRITE_REGISTERFILE_ACK  [i][j]->write(registerfile_ack );
664                  in_GPR_WRITE_STATUS_ACK        [i][j]->write(status_ack       );
665                 
666                 
667                  if (i == context)
668                    {
669                      gpr_write_registerfile_val [i][j] = val and status_ack      ;
670                      gpr_write_status_val       [i][j] = val and registerfile_ack;
671                     
672                      gpr_write_ack      [j] = registerfile_ack and status_ack;
673                    }
674                  else
675                    {
676                      gpr_write_registerfile_val [i][j] = 0;
677                      gpr_write_status_val       [i][j] = 0;
678                    }
679                 
680                }
681            }
682         
683          for (uint32_t j=0; j<_param->_nb_spr_write; j++)
684            {
685              context = (rand())%_param->_nb_ooo_engine;
686              Tcontrol_t      val = (rand()%100)<=percent_transaction;
687             
688              LABEL("SPR_WRITE [%d] : %d - %d",j,val,context);
689             
690              in_SPR_WRITE_VAL           [j] ->write(val);
691              in_SPR_WRITE_OOO_ENGINE_ID [j] ->write(context);
692             
693              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
694                {
695                  Tcontrol_t      registerfile_ack  = (rand()%100)<=percent_transaction  ;
696                  Tcontrol_t      status_ack        = (rand()%100)<=percent_transaction  ;
697                 
698                  in_SPR_WRITE_REGISTERFILE_ACK  [i][j]->write(registerfile_ack );
699                  in_SPR_WRITE_STATUS_ACK        [i][j]->write(status_ack       );
700                 
701                 
702                  if (i == context)
703                    {
704                      spr_write_registerfile_val [i][j] = val and status_ack      ;
705                      spr_write_status_val       [i][j] = val and registerfile_ack;
706                     
707                      spr_write_ack      [j] = registerfile_ack and status_ack;
708                    }
709                  else
710                    {
711                      spr_write_registerfile_val [i][j] = 0;
712                      spr_write_status_val       [i][j] = 0;
713                    }
714                }
715            }
716        }
717     
718//       if (test_retire == true)
719//      {
720//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
721//          {
722//            uint32_t x = _param->_nb_inst_retire_rob [i];
723
724//            for (uint32_t j=0; j<x; j++)
725//              {
726//              Tcontrol_t val                = (rand()%100)<=percent_transaction;
727//              Tcontrol_t rd_old_use         = (rand()%100)<=percent_transaction;
728//              Tcontrol_t rd_new_use         = (rand()%100)<=percent_transaction;
729//              Tcontrol_t re_old_use         = (rand()%100)<=percent_transaction;
730//              Tcontrol_t re_new_use         = (rand()%100)<=percent_transaction;
731//              Tcontrol_t gpr_status_old_ack = (rand()%100)<=percent_transaction;
732//              Tcontrol_t gpr_status_new_ack = (rand()%100)<=percent_transaction;
733//              Tcontrol_t spr_status_old_ack = (rand()%100)<=percent_transaction;
734//              Tcontrol_t spr_status_new_ack = (rand()%100)<=percent_transaction;
735                 
736//              in_RETIRE_ROB_VAL                [i][j]->write(val               );
737//              in_RETIRE_ROB_RD_OLD_USE         [i][j]->write(rd_old_use        );
738//              in_RETIRE_ROB_RD_NEW_USE         [i][j]->write(rd_new_use        );
739//              in_RETIRE_ROB_RE_OLD_USE         [i][j]->write(re_old_use        );
740//              in_RETIRE_ROB_RE_NEW_USE         [i][j]->write(re_new_use        );
741//              in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]->write(gpr_status_old_ack);
742//              in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]->write(gpr_status_new_ack);
743//              in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]->write(spr_status_old_ack);
744//              in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]->write(spr_status_new_ack);
745               
746//              retire_rob_ack                [i][j] = (gpr_status_new_ack and
747//                                                      gpr_status_old_ack and
748//                                                      spr_status_new_ack and
749//                                                      spr_status_old_ack);
750
751
752//              retire_rob_gpr_status_old_val [i][j] = val and rd_old_use                        and gpr_status_new_ack and spr_status_old_ack and spr_status_new_ack;
753//              retire_rob_gpr_status_new_val [i][j] = val and rd_new_use and gpr_status_old_ack                        and spr_status_old_ack and spr_status_new_ack;
754//              retire_rob_spr_status_old_val [i][j] = val and re_old_use and gpr_status_old_ack and gpr_status_new_ack                        and spr_status_new_ack;
755//              retire_rob_spr_status_new_val [i][j] = val and re_new_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_old_ack                       ;
756//              }
757//          }
758//      }
759
760      if (test_insert == true)
761        {
762          for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
763            {
764              uint32_t x = _param->_nb_inst_insert_rob [i];
765
766              for (uint32_t j=0; j<x; j++)
767                {
768                Tcontrol_t val            = (rand()%100)<=percent_transaction;
769                Tcontrol_t rd_use         = (rand()%100)<=percent_transaction; 
770                Tcontrol_t re_use         = (rand()%100)<=percent_transaction; 
771                Tcontrol_t gpr_status_ack = (rand()%100)<=percent_transaction;
772                Tcontrol_t spr_status_ack = (rand()%100)<=percent_transaction;
773                 
774                in_INSERT_ROB_VAL            [i][j]->write(val               );
775                in_INSERT_ROB_RD_USE         [i][j]->write(rd_use        ); 
776                in_INSERT_ROB_RE_USE         [i][j]->write(re_use        ); 
777                in_INSERT_ROB_GPR_STATUS_ACK [i][j]->write(gpr_status_ack);
778                in_INSERT_ROB_SPR_STATUS_ACK [i][j]->write(spr_status_ack);
779               
780                insert_rob_ack                [i][j] = (gpr_status_ack and
781                                                        spr_status_ack);
782
783
784                insert_rob_gpr_status_val [i][j] = val and rd_use                    and spr_status_ack;
785                insert_rob_spr_status_val [i][j] = val and re_use and gpr_status_ack                   ;
786                }
787            }
788        }
789
790      SC_START(0);
791
792      // Test
793      TEST(Tcontrol_t, out_CONST_0->read() , 0);
794      TEST(Tcontrol_t, out_CONST_1->read() , 1);
795     
796      if (test_read == true)
797        {
798          for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
799            {
800              TEST(Tcontrol_t     , out_GPR_READ_ACK           [j]->read(), gpr_read_ack     [j]);
801              TEST(Tgeneral_data_t, out_GPR_READ_DATA          [j]->read(), gpr_read_data    [j]);
802              TEST(Tcontrol_t     , out_GPR_READ_DATA_VAL      [j]->read(), gpr_read_data_val[j]);
803             
804              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
805                {
806                  TEST(Tcontrol_t, out_GPR_READ_REGISTERFILE_VAL  [i][j]->read(), gpr_read_registerfile_val [i][j]);
807                  TEST(Tcontrol_t, out_GPR_READ_STATUS_VAL        [i][j]->read(), gpr_read_status_val       [i][j]);
808                }
809            }
810          for (uint32_t j=0; j<_param->_nb_spr_read; j++)
811            {
812              TEST(Tcontrol_t     , out_SPR_READ_ACK           [j]->read(), spr_read_ack     [j]);
813              TEST(Tspecial_data_t, out_SPR_READ_DATA          [j]->read(), spr_read_data    [j]);
814              TEST(Tcontrol_t     , out_SPR_READ_DATA_VAL      [j]->read(), spr_read_data_val[j]);
815             
816              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
817                {
818                  TEST(Tcontrol_t, out_SPR_READ_REGISTERFILE_VAL  [i][j]->read(), spr_read_registerfile_val [i][j]);
819                  TEST(Tcontrol_t, out_SPR_READ_STATUS_VAL        [i][j]->read(), spr_read_status_val       [i][j]);
820                }
821            }
822        }
823     
824      if (test_write == true)
825        {
826          for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
827            {
828              TEST(Tcontrol_t     , out_GPR_WRITE_ACK           [j]->read(), gpr_write_ack     [j]);
829             
830              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
831                {
832                  TEST(Tcontrol_t, out_GPR_WRITE_REGISTERFILE_VAL  [i][j]->read(), gpr_write_registerfile_val [i][j]);
833                  TEST(Tcontrol_t, out_GPR_WRITE_STATUS_VAL        [i][j]->read(), gpr_write_status_val       [i][j]);
834                }
835            }
836          for (uint32_t j=0; j<_param->_nb_spr_write; j++)
837            {
838              TEST(Tcontrol_t     , out_SPR_WRITE_ACK           [j]->read(), spr_write_ack     [j]);
839             
840              for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
841                {
842                  TEST(Tcontrol_t, out_SPR_WRITE_REGISTERFILE_VAL  [i][j]->read(), spr_write_registerfile_val [i][j]);
843                  TEST(Tcontrol_t, out_SPR_WRITE_STATUS_VAL        [i][j]->read(), spr_write_status_val       [i][j]);
844                }
845            }
846        }
847
848
849//       if (test_retire == true)
850//      {
851//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
852//          {
853//            uint32_t x = _param->_nb_inst_retire_rob [i];
854
855//            for (uint32_t j=0; j<x; j++)
856//              {
857//                TEST(Tcontrol_t, out_RETIRE_ROB_ACK                [i][j]->read(), retire_rob_ack                [i][j]);
858//                TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_gpr_status_old_val [i][j]);
859//                TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_gpr_status_new_val [i][j]);
860//                TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_spr_status_old_val [i][j]);
861//                TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_spr_status_new_val [i][j]);
862//              }
863//          }
864//      }
865
866      if (test_insert == true)
867        {
868          for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
869            {
870              uint32_t x = _param->_nb_inst_insert_rob [i];
871
872              for (uint32_t j=0; j<x; j++)
873                {
874                  TEST(Tcontrol_t, out_INSERT_ROB_ACK            [i][j]->read(), insert_rob_ack            [i][j]);
875                  TEST(Tcontrol_t, out_INSERT_ROB_GPR_STATUS_VAL [i][j]->read(), insert_rob_gpr_status_val [i][j]);
876                  TEST(Tcontrol_t, out_INSERT_ROB_SPR_STATUS_VAL [i][j]->read(), insert_rob_spr_status_val [i][j]);
877                }
878            }
879        }
880
881
882      SC_START(1);
883    }
884
885  /********************************************************
886   * Simulation - End
887   ********************************************************/
888
889  TEST_OK ("End of Simulation");
890  delete _time;
891  cout << "<" << name << "> ............ Stop Simulation" << endl;
892
893  delete in_CLOCK;
894  delete in_NRESET;
895  delete []  in_GPR_READ_VAL               ;
896  delete [] out_GPR_READ_ACK               ;
897  delete []  in_GPR_READ_OOO_ENGINE_ID     ;
898  delete [] out_GPR_READ_DATA              ;
899  delete [] out_GPR_READ_DATA_VAL          ;
900  delete [] out_GPR_READ_REGISTERFILE_VAL  ;
901  delete []  in_GPR_READ_REGISTERFILE_ACK  ;
902  delete []  in_GPR_READ_REGISTERFILE_DATA ;
903  delete [] out_GPR_READ_STATUS_VAL        ;
904  delete []  in_GPR_READ_STATUS_ACK        ;
905  delete []  in_GPR_READ_STATUS_DATA_VAL   ;
906  delete []  in_SPR_READ_VAL               ;
907  delete [] out_SPR_READ_ACK               ;
908  delete []  in_SPR_READ_OOO_ENGINE_ID     ;
909  delete [] out_SPR_READ_DATA              ;
910  delete [] out_SPR_READ_DATA_VAL          ;
911  delete [] out_SPR_READ_REGISTERFILE_VAL  ;
912  delete []  in_SPR_READ_REGISTERFILE_ACK  ;
913  delete []  in_SPR_READ_REGISTERFILE_DATA ;
914  delete [] out_SPR_READ_STATUS_VAL        ;
915  delete []  in_SPR_READ_STATUS_ACK        ;
916  delete []  in_SPR_READ_STATUS_DATA_VAL   ;
917  delete []  in_GPR_WRITE_VAL               ;
918  delete [] out_GPR_WRITE_ACK               ;
919  delete []  in_GPR_WRITE_OOO_ENGINE_ID     ;
920  delete [] out_GPR_WRITE_REGISTERFILE_VAL  ;
921  delete []  in_GPR_WRITE_REGISTERFILE_ACK  ;
922  delete [] out_GPR_WRITE_STATUS_VAL        ;
923  delete []  in_GPR_WRITE_STATUS_ACK        ;
924  delete []  in_SPR_WRITE_VAL               ;
925  delete [] out_SPR_WRITE_ACK               ;
926  delete []  in_SPR_WRITE_OOO_ENGINE_ID     ;
927  delete [] out_SPR_WRITE_REGISTERFILE_VAL  ;
928  delete []  in_SPR_WRITE_REGISTERFILE_ACK  ;
929  delete [] out_SPR_WRITE_STATUS_VAL        ;
930  delete []  in_SPR_WRITE_STATUS_ACK        ;
931  delete []  in_INSERT_ROB_VAL                  ;
932  delete [] out_INSERT_ROB_ACK                  ;
933  delete []  in_INSERT_ROB_RD_USE               ;
934  delete []  in_INSERT_ROB_RE_USE               ;
935  delete [] out_INSERT_ROB_GPR_STATUS_VAL       ;
936  delete []  in_INSERT_ROB_GPR_STATUS_ACK       ;
937  delete [] out_INSERT_ROB_SPR_STATUS_VAL       ;
938  delete []  in_INSERT_ROB_SPR_STATUS_ACK       ;
939//   delete []  in_RETIRE_ROB_VAL                      ;
940//   delete [] out_RETIRE_ROB_ACK                      ;
941//   delete []  in_RETIRE_ROB_RD_OLD_USE               ;
942//   delete []  in_RETIRE_ROB_RD_NEW_USE               ;
943//   delete []  in_RETIRE_ROB_RE_OLD_USE               ;
944//   delete []  in_RETIRE_ROB_RE_NEW_USE               ;
945//   delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL       ;
946//   delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL       ;
947//   delete []  in_RETIRE_ROB_GPR_STATUS_OLD_ACK       ;
948//   delete []  in_RETIRE_ROB_GPR_STATUS_NEW_ACK       ;
949//   delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL       ;
950//   delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL       ;
951//   delete []  in_RETIRE_ROB_SPR_STATUS_OLD_ACK       ;
952//   delete []  in_RETIRE_ROB_SPR_STATUS_NEW_ACK       ;
953
954#endif
955
956  delete _Register_unit_Glue;
957#ifdef STATISTICS
958  delete _parameters_statistics;
959#endif
960}
Note: See TracBrowser for help on using the repository browser.