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

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

Almost complete design
with Test and test platform
  • Property svn:keywords set to Id
File size: 38.3 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  1
10#define CYCLE_MAX     (10240*NB_ITERATION)
11
12#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/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::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 * _Register_unit = new Register_unit
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
49    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
50  sc_signal<Tcontrol_t        >   **  in_GPR_READ_VAL                 ;
51  sc_signal<Tcontrol_t        >   ** out_GPR_READ_ACK                 ;
52  sc_signal<Tcontext_t        >   **  in_GPR_READ_OOO_ENGINE_ID       ;
53  sc_signal<Tgeneral_address_t>   **  in_GPR_READ_NUM_REG             ;
54  sc_signal<Tgeneral_data_t   >   ** out_GPR_READ_DATA                ;
55  sc_signal<Tcontrol_t        >   ** out_GPR_READ_DATA_VAL            ;
56
57    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
58  sc_signal<Tcontrol_t        >   **  in_GPR_WRITE_VAL                ;
59  sc_signal<Tcontrol_t        >   ** out_GPR_WRITE_ACK                ;
60  sc_signal<Tcontext_t        >   **  in_GPR_WRITE_OOO_ENGINE_ID      ;
61  sc_signal<Tgeneral_address_t>   **  in_GPR_WRITE_NUM_REG            ;
62  sc_signal<Tgeneral_data_t   >   **  in_GPR_WRITE_DATA               ;
63
64    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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_address_t>   **  in_SPR_READ_NUM_REG             ;
69  sc_signal<Tspecial_data_t   >   ** out_SPR_READ_DATA                ;
70  sc_signal<Tcontrol_t        >   ** out_SPR_READ_DATA_VAL            ;
71
72    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
73  sc_signal<Tcontrol_t        >   **  in_SPR_WRITE_VAL                ;
74  sc_signal<Tcontrol_t        >   ** out_SPR_WRITE_ACK                ;
75  sc_signal<Tcontext_t        >   **  in_SPR_WRITE_OOO_ENGINE_ID      ;
76  sc_signal<Tspecial_address_t>   **  in_SPR_WRITE_NUM_REG            ;
77  sc_signal<Tspecial_data_t   >   **  in_SPR_WRITE_DATA               ;
78   
79    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
80  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_VAL               ;
81  sc_signal<Tcontrol_t        >  *** out_INSERT_ROB_ACK               ;
82  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_RD_USE            ;
83  sc_signal<Tgeneral_address_t>  ***  in_INSERT_ROB_RD_NUM_REG        ; // use=1 : status[num_reg]<- 0
84  sc_signal<Tcontrol_t        >  ***  in_INSERT_ROB_RE_USE            ;
85  sc_signal<Tspecial_address_t>  ***  in_INSERT_ROB_RE_NUM_REG        ;
86
87//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
88//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_VAL               ;
89//   sc_signal<Tcontrol_t        >  *** out_RETIRE_ROB_ACK               ;
90//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_OLD_USE        ;
91//   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_OLD_NUM_REG    ; // old_use=1 : status[old_num_reg]<- 0
92//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RD_NEW_USE        ;
93//   sc_signal<Tgeneral_address_t>  ***  in_RETIRE_ROB_RD_NEW_NUM_REG    ; // new_use=1 : status[new_num_reg]<- 1
94//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_OLD_USE        ;
95//   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
96//   sc_signal<Tcontrol_t        >  ***  in_RETIRE_ROB_RE_NEW_USE        ;
97//   sc_signal<Tspecial_address_t>  ***  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
98
99  string rename = "signal";
100
101  in_CLOCK                                = new sc_clock ("clock", 1.0, 0.5);
102  in_NRESET                               = new sc_signal<Tcontrol_t> ("NRESET");
103
104
105    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
106      in_GPR_READ_VAL                 = new sc_signal<Tcontrol_t        > * [_param->_nb_gpr_read];
107     out_GPR_READ_ACK                 = new sc_signal<Tcontrol_t        > * [_param->_nb_gpr_read];
108      in_GPR_READ_OOO_ENGINE_ID       = new sc_signal<Tcontext_t        > * [_param->_nb_gpr_read];
109      in_GPR_READ_NUM_REG             = new sc_signal<Tgeneral_address_t> * [_param->_nb_gpr_read];
110     out_GPR_READ_DATA                = new sc_signal<Tgeneral_data_t   > * [_param->_nb_gpr_read];
111     out_GPR_READ_DATA_VAL            = new sc_signal<Tcontrol_t        > * [_param->_nb_gpr_read];
112     
113     for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
114       {
115          in_GPR_READ_VAL           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
116         out_GPR_READ_ACK           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
117          in_GPR_READ_OOO_ENGINE_ID [i]= new sc_signal<Tcontext_t        > (rename.c_str());
118          in_GPR_READ_NUM_REG       [i]= new sc_signal<Tgeneral_address_t> (rename.c_str());
119         out_GPR_READ_DATA          [i]= new sc_signal<Tgeneral_data_t   > (rename.c_str());
120         out_GPR_READ_DATA_VAL      [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
121       }
122
123    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
124      in_GPR_WRITE_VAL                 = new sc_signal<Tcontrol_t        > * [_param->_nb_gpr_write];
125     out_GPR_WRITE_ACK                 = new sc_signal<Tcontrol_t        > * [_param->_nb_gpr_write];
126      in_GPR_WRITE_OOO_ENGINE_ID       = new sc_signal<Tcontext_t        > * [_param->_nb_gpr_write];
127      in_GPR_WRITE_NUM_REG             = new sc_signal<Tgeneral_address_t> * [_param->_nb_gpr_write];
128      in_GPR_WRITE_DATA                = new sc_signal<Tgeneral_data_t   > * [_param->_nb_gpr_write];
129     
130     for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
131       {
132          in_GPR_WRITE_VAL           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
133         out_GPR_WRITE_ACK           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
134          in_GPR_WRITE_OOO_ENGINE_ID [i]= new sc_signal<Tcontext_t        > (rename.c_str());
135          in_GPR_WRITE_NUM_REG       [i]= new sc_signal<Tgeneral_address_t> (rename.c_str());
136          in_GPR_WRITE_DATA          [i]= new sc_signal<Tgeneral_data_t   > (rename.c_str());
137       }
138
139    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
140      in_SPR_READ_VAL                 = new sc_signal<Tcontrol_t        > * [_param->_nb_spr_read];
141     out_SPR_READ_ACK                 = new sc_signal<Tcontrol_t        > * [_param->_nb_spr_read];
142      in_SPR_READ_OOO_ENGINE_ID       = new sc_signal<Tcontext_t        > * [_param->_nb_spr_read];
143      in_SPR_READ_NUM_REG             = new sc_signal<Tspecial_address_t> * [_param->_nb_spr_read];
144     out_SPR_READ_DATA                = new sc_signal<Tspecial_data_t   > * [_param->_nb_spr_read];
145     out_SPR_READ_DATA_VAL            = new sc_signal<Tcontrol_t        > * [_param->_nb_spr_read];
146     
147     for (uint32_t i=0; i<_param->_nb_spr_read; i++)
148       {
149          in_SPR_READ_VAL           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
150         out_SPR_READ_ACK           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
151          in_SPR_READ_OOO_ENGINE_ID [i]= new sc_signal<Tcontext_t        > (rename.c_str());
152          in_SPR_READ_NUM_REG       [i]= new sc_signal<Tspecial_address_t> (rename.c_str());
153         out_SPR_READ_DATA          [i]= new sc_signal<Tspecial_data_t   > (rename.c_str());
154         out_SPR_READ_DATA_VAL      [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
155       }
156
157    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
158      in_SPR_WRITE_VAL                 = new sc_signal<Tcontrol_t        > * [_param->_nb_spr_write];
159     out_SPR_WRITE_ACK                 = new sc_signal<Tcontrol_t        > * [_param->_nb_spr_write];
160      in_SPR_WRITE_OOO_ENGINE_ID       = new sc_signal<Tcontext_t        > * [_param->_nb_spr_write];
161      in_SPR_WRITE_NUM_REG             = new sc_signal<Tspecial_address_t> * [_param->_nb_spr_write];
162      in_SPR_WRITE_DATA                = new sc_signal<Tspecial_data_t   > * [_param->_nb_spr_write];
163     
164     for (uint32_t i=0; i<_param->_nb_spr_write; i++)
165       {
166          in_SPR_WRITE_VAL           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
167         out_SPR_WRITE_ACK           [i]= new sc_signal<Tcontrol_t        > (rename.c_str());
168          in_SPR_WRITE_OOO_ENGINE_ID [i]= new sc_signal<Tcontext_t        > (rename.c_str());
169          in_SPR_WRITE_NUM_REG       [i]= new sc_signal<Tspecial_address_t> (rename.c_str());
170          in_SPR_WRITE_DATA          [i]= new sc_signal<Tspecial_data_t   > (rename.c_str());
171       }
172
173    // ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
174      in_INSERT_ROB_VAL        = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
175     out_INSERT_ROB_ACK        = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
176      in_INSERT_ROB_RD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
177      in_INSERT_ROB_RD_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
178      in_INSERT_ROB_RE_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
179      in_INSERT_ROB_RE_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
180
181     for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
182       {
183         uint32_t x=_param->_nb_inst_insert_rob [i];
184
185          in_INSERT_ROB_VAL        [i] = new sc_signal<Tcontrol_t        > * [x];
186         out_INSERT_ROB_ACK        [i] = new sc_signal<Tcontrol_t        > * [x];
187          in_INSERT_ROB_RD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
188          in_INSERT_ROB_RD_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
189          in_INSERT_ROB_RE_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
190          in_INSERT_ROB_RE_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
191
192         for (uint32_t j=0; j<x; j++)
193           {
194              in_INSERT_ROB_VAL        [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
195             out_INSERT_ROB_ACK        [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
196              in_INSERT_ROB_RD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
197              in_INSERT_ROB_RD_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
198              in_INSERT_ROB_RE_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
199              in_INSERT_ROB_RE_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
200             
201           }
202       }
203
204//     // ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
205//       in_RETIRE_ROB_VAL            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
206//      out_RETIRE_ROB_ACK            = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
207//       in_RETIRE_ROB_RD_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
208//       in_RETIRE_ROB_RD_OLD_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
209//       in_RETIRE_ROB_RE_OLD_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
210//       in_RETIRE_ROB_RE_OLD_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
211//       in_RETIRE_ROB_RD_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
212//       in_RETIRE_ROB_RD_NEW_NUM_REG = new sc_signal<Tgeneral_address_t> ** [_param->_nb_ooo_engine];
213//       in_RETIRE_ROB_RE_NEW_USE     = new sc_signal<Tcontrol_t        > ** [_param->_nb_ooo_engine];
214//       in_RETIRE_ROB_RE_NEW_NUM_REG = new sc_signal<Tspecial_address_t> ** [_param->_nb_ooo_engine];
215
216//      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
217//        {
218//       uint32_t x=_param->_nb_inst_retire_rob [i];
219
220//        in_RETIRE_ROB_VAL            [i] = new sc_signal<Tcontrol_t        > * [x];
221//       out_RETIRE_ROB_ACK            [i] = new sc_signal<Tcontrol_t        > * [x];
222//        in_RETIRE_ROB_RD_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
223//        in_RETIRE_ROB_RD_OLD_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
224//        in_RETIRE_ROB_RE_OLD_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
225//        in_RETIRE_ROB_RE_OLD_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
226//        in_RETIRE_ROB_RD_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
227//        in_RETIRE_ROB_RD_NEW_NUM_REG [i] = new sc_signal<Tgeneral_address_t> * [x];
228//        in_RETIRE_ROB_RE_NEW_USE     [i] = new sc_signal<Tcontrol_t        > * [x];
229//        in_RETIRE_ROB_RE_NEW_NUM_REG [i] = new sc_signal<Tspecial_address_t> * [x];
230
231//       for (uint32_t j=0; j<x; j++)
232//         {
233//            in_RETIRE_ROB_VAL            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
234//           out_RETIRE_ROB_ACK            [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
235//            in_RETIRE_ROB_RD_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
236//            in_RETIRE_ROB_RD_OLD_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
237//            in_RETIRE_ROB_RE_OLD_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
238//            in_RETIRE_ROB_RE_OLD_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
239//            in_RETIRE_ROB_RD_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
240//            in_RETIRE_ROB_RD_NEW_NUM_REG [i][j] = new sc_signal<Tgeneral_address_t> (rename.c_str());
241//            in_RETIRE_ROB_RE_NEW_USE     [i][j] = new sc_signal<Tcontrol_t        > (rename.c_str());
242//            in_RETIRE_ROB_RE_NEW_NUM_REG [i][j] = new sc_signal<Tspecial_address_t> (rename.c_str());
243//         }
244//        }
245
246 
247  /********************************************************
248   * Instanciation
249   ********************************************************/
250 
251  cout << "<" << name << "> Instanciation of _Register_unit" << endl;
252 
253  (*(_Register_unit->in_CLOCK))        (*(in_CLOCK));
254  (*(_Register_unit->in_NRESET))       (*(in_NRESET));
255 
256  for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
257    {
258      (*(_Register_unit-> in_GPR_READ_VAL           [i]))(*( in_GPR_READ_VAL           [i]));
259      (*(_Register_unit->out_GPR_READ_ACK           [i]))(*(out_GPR_READ_ACK           [i]));
260      if (_param->_have_port_ooo_engine_id == true)
261        (*(_Register_unit-> in_GPR_READ_OOO_ENGINE_ID [i]))(*( in_GPR_READ_OOO_ENGINE_ID [i]));
262      (*(_Register_unit-> in_GPR_READ_NUM_REG       [i]))(*( in_GPR_READ_NUM_REG       [i]));
263      (*(_Register_unit->out_GPR_READ_DATA          [i]))(*(out_GPR_READ_DATA          [i]));
264      (*(_Register_unit->out_GPR_READ_DATA_VAL      [i]))(*(out_GPR_READ_DATA_VAL      [i]));
265    }
266  for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
267    {
268      (*(_Register_unit-> in_GPR_WRITE_VAL           [i]))(*( in_GPR_WRITE_VAL           [i]));
269      (*(_Register_unit->out_GPR_WRITE_ACK           [i]))(*(out_GPR_WRITE_ACK           [i]));
270      if (_param->_have_port_ooo_engine_id == true)
271        (*(_Register_unit-> in_GPR_WRITE_OOO_ENGINE_ID [i]))(*( in_GPR_WRITE_OOO_ENGINE_ID [i]));
272      (*(_Register_unit-> in_GPR_WRITE_NUM_REG       [i]))(*( in_GPR_WRITE_NUM_REG       [i]));
273      (*(_Register_unit-> in_GPR_WRITE_DATA          [i]))(*( in_GPR_WRITE_DATA          [i]));
274    }
275  for (uint32_t i=0; i<_param->_nb_spr_read; i++)
276    {
277      (*(_Register_unit-> in_SPR_READ_VAL           [i]))(*( in_SPR_READ_VAL           [i]));
278      (*(_Register_unit->out_SPR_READ_ACK           [i]))(*(out_SPR_READ_ACK           [i]));
279      if (_param->_have_port_ooo_engine_id == true)
280        (*(_Register_unit-> in_SPR_READ_OOO_ENGINE_ID [i]))(*( in_SPR_READ_OOO_ENGINE_ID [i]));
281      (*(_Register_unit-> in_SPR_READ_NUM_REG       [i]))(*( in_SPR_READ_NUM_REG       [i]));
282      (*(_Register_unit->out_SPR_READ_DATA          [i]))(*(out_SPR_READ_DATA          [i]));
283      (*(_Register_unit->out_SPR_READ_DATA_VAL      [i]))(*(out_SPR_READ_DATA_VAL      [i]));
284    }
285  for (uint32_t i=0; i<_param->_nb_spr_write; i++)
286    {
287      (*(_Register_unit-> in_SPR_WRITE_VAL           [i]))(*( in_SPR_WRITE_VAL           [i]));
288      (*(_Register_unit->out_SPR_WRITE_ACK           [i]))(*(out_SPR_WRITE_ACK           [i]));
289      if (_param->_have_port_ooo_engine_id == true)
290        (*(_Register_unit-> in_SPR_WRITE_OOO_ENGINE_ID [i]))(*( in_SPR_WRITE_OOO_ENGINE_ID [i]));
291      (*(_Register_unit-> in_SPR_WRITE_NUM_REG       [i]))(*( in_SPR_WRITE_NUM_REG       [i]));
292      (*(_Register_unit-> in_SPR_WRITE_DATA          [i]))(*( in_SPR_WRITE_DATA          [i]));
293    }
294  for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
295    for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
296      {
297        (*(_Register_unit-> in_INSERT_ROB_VAL        [i][j]))(*( in_INSERT_ROB_VAL        [i][j]));
298        (*(_Register_unit->out_INSERT_ROB_ACK        [i][j]))(*(out_INSERT_ROB_ACK        [i][j]));
299        (*(_Register_unit-> in_INSERT_ROB_RD_USE     [i][j]))(*( in_INSERT_ROB_RD_USE     [i][j]));
300        (*(_Register_unit-> in_INSERT_ROB_RD_NUM_REG [i][j]))(*( in_INSERT_ROB_RD_NUM_REG [i][j]));
301        (*(_Register_unit-> in_INSERT_ROB_RE_USE     [i][j]))(*( in_INSERT_ROB_RE_USE     [i][j]));
302        (*(_Register_unit-> in_INSERT_ROB_RE_NUM_REG [i][j]))(*( in_INSERT_ROB_RE_NUM_REG [i][j]));
303      }
304//   for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
305//     for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
306//       {
307//      (*(_Register_unit-> in_RETIRE_ROB_VAL            [i][j]))(*( in_RETIRE_ROB_VAL            [i][j]));
308//      (*(_Register_unit->out_RETIRE_ROB_ACK            [i][j]))(*(out_RETIRE_ROB_ACK            [i][j]));
309//      (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RD_OLD_USE     [i][j]));
310//      (*(_Register_unit-> in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]));
311//      (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_USE     [i][j]))(*( in_RETIRE_ROB_RE_OLD_USE     [i][j]));
312//      (*(_Register_unit-> in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]));
313//      (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RD_NEW_USE     [i][j]));
314//      (*(_Register_unit-> in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]));
315//      (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_USE     [i][j]))(*( in_RETIRE_ROB_RE_NEW_USE     [i][j]));
316//      (*(_Register_unit-> in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]))(*( in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]));
317//       }
318 
319  cout << "<" << name << "> Start Simulation ............" << endl;
320  Time * _time = new Time();
321
322  /********************************************************
323   * Simulation - Begin
324   ********************************************************/
325
326  // Initialisation
327  uint32_t        max_nb_general_register = 0;
328
329  for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
330    if (_param->_nb_general_register [i] > max_nb_general_register)
331      max_nb_general_register = _param->_nb_general_register [i];
332
333  uint32_t        max_nb_special_register = 0;
334
335  for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
336    if (_param->_nb_special_register [i] > max_nb_special_register)
337      max_nb_special_register = _param->_nb_special_register [i];
338
339  const  int32_t percent_transaction_read       = 70;
340  const  int32_t percent_transaction_write      = 70;
341  const  int32_t percent_transaction_insert     = 70;
342  const  int32_t percent_transaction_insert_use = 70;
343//   const  int32_t percent_transaction_retire     = 70;
344//   const  int32_t percent_transaction_retire_use = 70;
345  const uint32_t nb_request                     = max_nb_general_register;
346
347  const uint32_t seed = 0;
348//const uint32_t seed = static_cast<uint32_t>(time(NULL));
349
350  srand(seed);
351
352  Tgeneral_data_t    gpr        [_param->_nb_ooo_engine][max_nb_general_register];
353  Tcontrol_t         gpr_status [_param->_nb_ooo_engine][max_nb_general_register];
354  Tspecial_data_t    spr        [_param->_nb_ooo_engine][max_nb_special_register];
355  Tcontrol_t         spr_status [_param->_nb_ooo_engine][max_nb_special_register];
356
357  SC_START(0);
358
359  LABEL("Initialisation");
360
361  in_NRESET->write(0);
362  SC_START(5);
363  in_NRESET->write(1);
364
365  for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
366    in_GPR_READ_VAL  [i]->write(0);
367  for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
368    in_GPR_WRITE_VAL [i]->write(0);
369  for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
370    in_SPR_READ_VAL  [i]->write(0);
371  for (uint32_t i=0; i<_param->_nb_spr_write; i++)
372    in_SPR_WRITE_VAL [i]->write(0);
373  for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
374    {
375      for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
376        in_INSERT_ROB_VAL [i][j]->write(0);
377//       for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
378//      in_RETIRE_ROB_VAL [i][j]->write(0);
379    }
380     
381  Tgeneral_address_t gpr_address [_param->_nb_gpr_write];
382  Tgeneral_address_t gpr_address_next;
383  uint32_t           nb_port_gpr_active; // number of port active
384
385  Tspecial_address_t spr_address [_param->_nb_spr_write];
386  Tspecial_address_t spr_address_next;
387  uint32_t           nb_port_spr_active; // number of port active
388
389  LABEL("Loop of Test");
390
391  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
392    {
393      LABEL("Iteration %d",iteration);
394
395      LABEL("(GPR) Write default value");
396
397      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
398        for(uint32_t j=0; j<max_nb_general_register; j++)
399          {
400            gpr        [i][j] = rand()%_param->_size_general_data;
401            gpr_status [i][j] = 1;
402          }
403
404      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
405        {
406          gpr_address_next   = _param->_nb_gpr_write;
407          nb_port_gpr_active = _param->_nb_gpr_write;
408         
409          for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
410            {
411              gpr_address[j] = j;
412              if (j >= _param->_nb_general_register [i])
413                nb_port_gpr_active --;
414            }
415         
416          while (nb_port_gpr_active > 0)
417            {
418              for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
419                {
420                  in_GPR_WRITE_VAL           [j]->write((gpr_address[j] < _param->_nb_general_register [i]) and
421                                                        ((rand() % 100) < percent_transaction_write));
422                  in_GPR_WRITE_OOO_ENGINE_ID [j]->write(i);
423                  in_GPR_WRITE_NUM_REG       [j]->write(gpr_address[j]);
424                  in_GPR_WRITE_DATA          [j]->write(gpr [i][gpr_address[j]]);
425                }
426             
427              SC_START(1);
428
429              // Test if write
430              for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
431                if (in_GPR_WRITE_VAL [j]->read() and out_GPR_WRITE_ACK [j]->read())
432                  {
433                    gpr_address[j] = gpr_address_next;
434
435                    if (gpr_address_next >= _param->_nb_general_register [i])
436                      nb_port_gpr_active --;               
437                   
438                    gpr_address_next ++;
439                  }
440            }
441        }
442     
443      for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
444        in_GPR_WRITE_VAL [i]->write(0);
445
446      LABEL("(GPR) Read - and test data writted");
447     
448      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
449        {
450          gpr_address_next   = _param->_nb_gpr_read;
451          nb_port_gpr_active = _param->_nb_gpr_read;
452         
453          for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
454            {
455              gpr_address[j] = j;
456              if (j >= _param->_nb_general_register [i])
457                nb_port_gpr_active --;
458            }
459         
460          while (nb_port_gpr_active > 0)
461            {
462              for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
463                {
464                  in_GPR_READ_VAL           [j]->write((gpr_address[j] < _param->_nb_general_register [i]) and
465                                                       ((rand() % 100) < percent_transaction_read));
466                  in_GPR_READ_OOO_ENGINE_ID [j]->write(i);
467                  in_GPR_READ_NUM_REG       [j]->write(gpr_address[j]);
468                }
469             
470              SC_START(1);
471
472              // Test if read
473              for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
474                if (in_GPR_READ_VAL [j]->read() and out_GPR_READ_ACK [j]->read())
475                  {
476                    TEST(Tgeneral_data_t, out_GPR_READ_DATA    [j]->read(), gpr        [i][gpr_address[j]]);
477                    TEST(Tcontrol_t     , out_GPR_READ_DATA_VAL[j]->read(), gpr_status [i][gpr_address[j]]);
478
479                    gpr_address[j] = gpr_address_next;
480
481                    if (gpr_address_next >= _param->_nb_general_register [i])
482                      nb_port_gpr_active --;               
483                   
484                    gpr_address_next ++;
485                  }
486            }
487        }
488
489      for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
490        in_GPR_READ_VAL [i]->write(0);
491
492      LABEL("(SPR) Write default value");
493
494      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
495        for(uint32_t j=0; j<max_nb_special_register; j++)
496          {
497            spr        [i][j] = rand()%_param->_size_special_data;
498            spr_status [i][j] = 1;
499          }
500
501      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
502        {
503          spr_address_next   = _param->_nb_spr_write;
504          nb_port_spr_active = _param->_nb_spr_write;
505         
506          for (uint32_t j=0; j<_param->_nb_spr_write; j++)
507            {
508              spr_address[j] = j;
509              if (j >= _param->_nb_special_register [i])
510                nb_port_spr_active --;
511            }
512         
513          while (nb_port_spr_active > 0)
514            {
515              for (uint32_t j=0; j<_param->_nb_spr_write; j++)
516                {
517                  in_SPR_WRITE_VAL           [j]->write((spr_address[j] < _param->_nb_special_register [i]) and
518                                                        ((rand() % 100) < percent_transaction_write));
519                  in_SPR_WRITE_OOO_ENGINE_ID [j]->write(i);
520                  in_SPR_WRITE_NUM_REG       [j]->write(spr_address[j]);
521                  in_SPR_WRITE_DATA          [j]->write(spr [i][spr_address[j]]);
522                }
523             
524              SC_START(1);
525
526              // Test if write
527              for (uint32_t j=0; j<_param->_nb_spr_write; j++)
528                if (in_SPR_WRITE_VAL [j]->read() and out_SPR_WRITE_ACK [j]->read())
529                  {
530                    spr_address[j] = spr_address_next;
531
532                    if (spr_address_next >= _param->_nb_special_register [i])
533                      nb_port_spr_active --;               
534                   
535                    spr_address_next ++;
536                  }
537            }
538        }
539     
540      for (uint32_t i=0; i<_param->_nb_spr_write; i++)
541        in_SPR_WRITE_VAL [i]->write(0);
542
543      LABEL("(SPR) Read - and test data writted");
544     
545      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
546        {
547          spr_address_next   = _param->_nb_spr_read;
548          nb_port_spr_active = _param->_nb_spr_read;
549         
550          for (uint32_t j=0; j<_param->_nb_spr_read; j++)
551            {
552              spr_address[j] = j;
553              if (j >= _param->_nb_special_register [i])
554                nb_port_spr_active --;
555            }
556         
557          while (nb_port_spr_active > 0)
558            {
559              for (uint32_t j=0; j<_param->_nb_spr_read; j++)
560                {
561                  in_SPR_READ_VAL           [j]->write((spr_address[j] < _param->_nb_special_register [i]) and
562                                                       ((rand() % 100) < percent_transaction_read));
563                  in_SPR_READ_OOO_ENGINE_ID [j]->write(i);
564                  in_SPR_READ_NUM_REG       [j]->write(spr_address[j]);
565                }
566             
567              SC_START(1);
568
569              // Test if read
570              for (uint32_t j=0; j<_param->_nb_spr_read; j++)
571                if (in_SPR_READ_VAL [j]->read() and out_SPR_READ_ACK [j]->read())
572                  {
573                    TEST(Tspecial_data_t, out_SPR_READ_DATA    [j]->read(), spr        [i][spr_address[j]]);
574                    TEST(Tcontrol_t     , out_SPR_READ_DATA_VAL[j]->read(), spr_status [i][spr_address[j]]);
575
576                    spr_address[j] = spr_address_next;
577
578                    if (spr_address_next >= _param->_nb_special_register [i])
579                      nb_port_spr_active --;               
580                   
581                    spr_address_next ++;
582                  }
583            }
584        }
585
586      for (uint32_t i=0; i<_param->_nb_spr_read; i++)
587        in_SPR_READ_VAL [i]->write(0);
588     
589      LABEL("insert rob");
590
591      uint32_t cpt = 0;
592     
593      while (cpt < nb_request)
594        {
595          for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
596            {
597              uint32_t x=_param->_nb_inst_insert_rob [i];
598              for (uint32_t j=0; j<x; j++)
599                {
600                  in_INSERT_ROB_VAL        [i][j]->write((rand() % 100) < percent_transaction_insert);
601                  in_INSERT_ROB_RD_USE     [i][j]->write((rand() % 100) < percent_transaction_insert_use);
602                  in_INSERT_ROB_RD_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
603                  in_INSERT_ROB_RE_USE     [i][j]->write((rand() % 100) < percent_transaction_insert_use);
604                  in_INSERT_ROB_RE_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);
605                }
606            }
607         
608          SC_START(1);
609         
610          for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
611            {
612              uint32_t x=_param->_nb_inst_insert_rob [i];
613              for (uint32_t j=0; j<x; j++)
614                {
615                  if (in_INSERT_ROB_VAL [i][j]->read() and out_INSERT_ROB_ACK [i][j]->read())
616                    {
617                      cpt ++;
618                     
619                      if (in_INSERT_ROB_RD_USE [i][j]->read())
620                        gpr_status [i][in_INSERT_ROB_RD_NUM_REG [i][j]->read()] = 0;
621                     
622                      if (in_INSERT_ROB_RE_USE [i][j]->read())
623                        spr_status [i][in_INSERT_ROB_RE_NUM_REG [i][j]->read()] = 0;
624                    }
625                }
626            }
627        }
628      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
629        for (uint32_t j=0; j<_param->_nb_inst_insert_rob [i]; j++)
630          in_INSERT_ROB_VAL [i][j]->write(0);
631
632      LABEL("(GPR) Read - and test data writted");
633     
634      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
635        {
636          gpr_address_next   = _param->_nb_gpr_read;
637          nb_port_gpr_active = _param->_nb_gpr_read;
638         
639          for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
640            {
641              gpr_address[j] = j;
642              if (j >= _param->_nb_general_register [i])
643                nb_port_gpr_active --;
644            }
645         
646          while (nb_port_gpr_active > 0)
647            {
648              for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
649                {
650                  in_GPR_READ_VAL           [j]->write((gpr_address[j] < _param->_nb_general_register [i]) and
651                                                       ((rand() % 100) < percent_transaction_read));
652                  in_GPR_READ_OOO_ENGINE_ID [j]->write(i);
653                  in_GPR_READ_NUM_REG       [j]->write(gpr_address[j]);
654                }
655             
656              SC_START(1);
657
658              // Test if read
659              for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
660                if (in_GPR_READ_VAL [j]->read() and out_GPR_READ_ACK [j]->read())
661                  {
662                    TEST(Tgeneral_data_t, out_GPR_READ_DATA    [j]->read(), gpr        [i][gpr_address[j]]);
663                    TEST(Tcontrol_t     , out_GPR_READ_DATA_VAL[j]->read(), gpr_status [i][gpr_address[j]]);
664
665                    gpr_address[j] = gpr_address_next;
666
667                    if (gpr_address_next >= _param->_nb_general_register [i])
668                      nb_port_gpr_active --;               
669                   
670                    gpr_address_next ++;
671                  }
672            }
673        }
674
675      for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
676        in_GPR_READ_VAL [i]->write(0);
677
678      LABEL("(SPR) Read - and test data writted");
679     
680      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
681        {
682          spr_address_next   = _param->_nb_spr_read;
683          nb_port_spr_active = _param->_nb_spr_read;
684         
685          for (uint32_t j=0; j<_param->_nb_spr_read; j++)
686            {
687              spr_address[j] = j;
688              if (j >= _param->_nb_special_register [i])
689                nb_port_spr_active --;
690            }
691         
692          while (nb_port_spr_active > 0)
693            {
694              for (uint32_t j=0; j<_param->_nb_spr_read; j++)
695                {
696                  in_SPR_READ_VAL           [j]->write((spr_address[j] < _param->_nb_special_register [i]) and
697                                                       ((rand() % 100) < percent_transaction_read));
698                  in_SPR_READ_OOO_ENGINE_ID [j]->write(i);
699                  in_SPR_READ_NUM_REG       [j]->write(spr_address[j]);
700                }
701             
702              SC_START(1);
703
704              // Test if read
705              for (uint32_t j=0; j<_param->_nb_spr_read; j++)
706                if (in_SPR_READ_VAL [j]->read() and out_SPR_READ_ACK [j]->read())
707                  {
708                    TEST(Tspecial_data_t, out_SPR_READ_DATA    [j]->read(), spr        [i][spr_address[j]]);
709                    TEST(Tcontrol_t     , out_SPR_READ_DATA_VAL[j]->read(), spr_status [i][spr_address[j]]);
710
711                    spr_address[j] = spr_address_next;
712
713                    if (spr_address_next >= _param->_nb_special_register [i])
714                      nb_port_spr_active --;               
715                   
716                    spr_address_next ++;
717                  }
718            }
719        }
720
721//       LABEL("retire rob");
722
723//       cpt = 0;
724     
725//       while (cpt < nb_request)
726//      {
727//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
728//          {
729//            uint32_t x=_param->_nb_inst_retire_rob [i];
730//            for (uint32_t j=0; j<x; j++)
731//              {
732//                in_RETIRE_ROB_VAL            [i][j]->write((rand() % 100) < percent_transaction_retire);
733//                in_RETIRE_ROB_RD_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
734//                in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);
735//                in_RETIRE_ROB_RD_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
736//                in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_general_register [i]);           
737//                in_RETIRE_ROB_RE_OLD_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
738//                in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);           
739//                in_RETIRE_ROB_RE_NEW_USE     [i][j]->write((rand() % 100) < percent_transaction_retire_use);
740//                in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->write(rand() % _param->_nb_special_register [i]);           
741//              }
742//          }
743         
744//        SC_START(1);
745         
746//        for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
747//          {
748//            uint32_t x=_param->_nb_inst_retire_rob [i];
749//            for (uint32_t j=0; j<x; j++)
750//              {
751//                if (in_RETIRE_ROB_VAL [i][j]->read() and out_RETIRE_ROB_ACK [i][j]->read())
752//                  {
753//                    cpt ++;
754                     
755//                    if (in_RETIRE_ROB_RD_OLD_USE [i][j]->read())
756//                      gpr_status [i][in_RETIRE_ROB_RD_OLD_NUM_REG [i][j]->read()] = 0;
757//                    if (in_RETIRE_ROB_RD_NEW_USE [i][j]->read())
758//                      gpr_status [i][in_RETIRE_ROB_RD_NEW_NUM_REG [i][j]->read()] = 1;
759//                    if (in_RETIRE_ROB_RE_OLD_USE [i][j]->read())
760//                      spr_status [i][in_RETIRE_ROB_RE_OLD_NUM_REG [i][j]->read()] = 0;
761//                    if (in_RETIRE_ROB_RE_NEW_USE [i][j]->read())
762//                      spr_status [i][in_RETIRE_ROB_RE_NEW_NUM_REG [i][j]->read()] = 1;
763//                  }
764//              }
765//          }
766//      }
767//       for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
768//      for (uint32_t j=0; j<_param->_nb_inst_retire_rob [i]; j++)
769//        in_RETIRE_ROB_VAL [i][j]->write(0);
770
771      LABEL("(GPR) Read - and test data writted");
772     
773      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
774        {
775          gpr_address_next   = _param->_nb_gpr_read;
776          nb_port_gpr_active = _param->_nb_gpr_read;
777         
778          for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
779            {
780              gpr_address[j] = j;
781              if (j >= _param->_nb_general_register [i])
782                nb_port_gpr_active --;
783            }
784         
785          while (nb_port_gpr_active > 0)
786            {
787              for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
788                {
789                  in_GPR_READ_VAL           [j]->write((gpr_address[j] < _param->_nb_general_register [i]) and
790                                                       ((rand() % 100) < percent_transaction_read));
791                  in_GPR_READ_OOO_ENGINE_ID [j]->write(i);
792                  in_GPR_READ_NUM_REG       [j]->write(gpr_address[j]);
793                }
794             
795              SC_START(1);
796
797              // Test if read
798              for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
799                if (in_GPR_READ_VAL [j]->read() and out_GPR_READ_ACK [j]->read())
800                  {
801                    TEST(Tgeneral_data_t, out_GPR_READ_DATA    [j]->read(), gpr        [i][gpr_address[j]]);
802                    TEST(Tcontrol_t     , out_GPR_READ_DATA_VAL[j]->read(), gpr_status [i][gpr_address[j]]);
803
804                    gpr_address[j] = gpr_address_next;
805
806                    if (gpr_address_next >= _param->_nb_general_register [i])
807                      nb_port_gpr_active --;               
808                   
809                    gpr_address_next ++;
810                  }
811            }
812        }
813
814      for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
815        in_GPR_READ_VAL [i]->write(0);
816
817      LABEL("(SPR) Read - and test data writted");
818     
819      for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
820        {
821          spr_address_next   = _param->_nb_spr_read;
822          nb_port_spr_active = _param->_nb_spr_read;
823         
824          for (uint32_t j=0; j<_param->_nb_spr_read; j++)
825            {
826              spr_address[j] = j;
827              if (j >= _param->_nb_special_register [i])
828                nb_port_spr_active --;
829            }
830         
831          while (nb_port_spr_active > 0)
832            {
833              for (uint32_t j=0; j<_param->_nb_spr_read; j++)
834                {
835                  in_SPR_READ_VAL           [j]->write((spr_address[j] < _param->_nb_special_register [i]) and
836                                                       ((rand() % 100) < percent_transaction_read));
837                  in_SPR_READ_OOO_ENGINE_ID [j]->write(i);
838                  in_SPR_READ_NUM_REG       [j]->write(spr_address[j]);
839                }
840             
841              SC_START(1);
842
843              // Test if read
844              for (uint32_t j=0; j<_param->_nb_spr_read; j++)
845                if (in_SPR_READ_VAL [j]->read() and out_SPR_READ_ACK [j]->read())
846                  {
847                    TEST(Tspecial_data_t, out_SPR_READ_DATA    [j]->read(), spr        [i][spr_address[j]]);
848                    TEST(Tcontrol_t     , out_SPR_READ_DATA_VAL[j]->read(), spr_status [i][spr_address[j]]);
849
850                    spr_address[j] = spr_address_next;
851
852                    if (spr_address_next >= _param->_nb_special_register [i])
853                      nb_port_spr_active --;               
854                   
855                    spr_address_next ++;
856                  }
857            }
858        }
859
860    }
861
862  /********************************************************
863   * Simulation - End
864   ********************************************************/
865
866  TEST_OK ("End of Simulation");
867  delete _time;
868  cout << "<" << name << "> ............ Stop Simulation" << endl;
869
870  delete in_CLOCK;
871  delete in_NRESET;
872
873  delete []  in_GPR_READ_VAL                 ;
874  delete [] out_GPR_READ_ACK                 ;
875  delete []  in_GPR_READ_OOO_ENGINE_ID       ;
876  delete []  in_GPR_READ_NUM_REG             ;
877  delete [] out_GPR_READ_DATA                ;
878  delete [] out_GPR_READ_DATA_VAL            ;
879  delete []  in_GPR_WRITE_VAL                ;
880  delete [] out_GPR_WRITE_ACK                ;
881  delete []  in_GPR_WRITE_OOO_ENGINE_ID      ;
882  delete []  in_GPR_WRITE_NUM_REG            ;
883  delete []  in_GPR_WRITE_DATA               ;
884  delete []  in_SPR_READ_VAL                 ;
885  delete [] out_SPR_READ_ACK                 ;
886  delete []  in_SPR_READ_OOO_ENGINE_ID       ;
887  delete []  in_SPR_READ_NUM_REG             ;
888  delete [] out_SPR_READ_DATA                ;
889  delete [] out_SPR_READ_DATA_VAL            ;
890  delete []  in_SPR_WRITE_VAL                ;
891  delete [] out_SPR_WRITE_ACK                ;
892  delete []  in_SPR_WRITE_OOO_ENGINE_ID      ;
893  delete []  in_SPR_WRITE_NUM_REG            ;
894  delete []  in_SPR_WRITE_DATA               ;
895  delete []  in_INSERT_ROB_VAL               ;
896  delete [] out_INSERT_ROB_ACK               ;
897  delete []  in_INSERT_ROB_RD_USE            ;
898  delete []  in_INSERT_ROB_RD_NUM_REG        ;
899  delete []  in_INSERT_ROB_RE_USE            ;
900  delete []  in_INSERT_ROB_RE_NUM_REG        ;
901//   delete []  in_RETIRE_ROB_VAL               ;
902//   delete [] out_RETIRE_ROB_ACK               ;
903//   delete []  in_RETIRE_ROB_RD_OLD_USE        ;
904//   delete []  in_RETIRE_ROB_RD_OLD_NUM_REG    ;
905//   delete []  in_RETIRE_ROB_RD_NEW_USE        ;
906//   delete []  in_RETIRE_ROB_RD_NEW_NUM_REG    ;
907//   delete []  in_RETIRE_ROB_RE_OLD_USE        ;
908//   delete []  in_RETIRE_ROB_RE_OLD_NUM_REG    ;
909//   delete []  in_RETIRE_ROB_RE_NEW_USE        ;
910//   delete []  in_RETIRE_ROB_RE_NEW_NUM_REG    ;
911#endif
912
913  delete _Register_unit;
914#ifdef STATISTICS
915  delete _parameters_statistics;
916#endif
917}
Note: See TracBrowser for help on using the repository browser.