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