source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/src/test.cpp @ 69

Last change on this file since 69 was 69, checked in by rosiere, 17 years ago

Station de reservation : systemC et VHDL ok
File size: 38.8 KB
Line 
1/*
2 * $Id$
3 *
4 * [ Description ]
5 *
6 * Test
7 */
8
9#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Reservation_station/SelfTest/include/test.h"
10#include "Common/include/Test.h"
11
12#define NB_ITERATION  2
13#define CYCLE_MAX     (2048*NB_ITERATION)
14
15#define LABEL(str)                                                                       \
16{                                                                                        \
17  cout << "{"+toString(static_cast<uint32_t>(sc_simulation_time()))+"} " << str << endl; \
18} while(0)
19
20static uint32_t cycle = 0;
21
22#define SC_START(cycle_offset)                                          \
23do                                                                      \
24{                                                                       \
25/*cout << "SC_START (begin)" << endl;*/                                 \
26                                                                        \
27  uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time()); \
28  sc_start(cycle_offset);                                               \
29  if (cycle_current != cycle)                                           \
30    {                                                                   \
31      cycle = cycle_current;                                            \
32      cout << "##########[ cycle "<< cycle << " ]" << endl;             \
33    }                                                                   \
34                                                                        \
35  if (cycle_current > CYCLE_MAX)                                        \
36    {                                                                   \
37      TEST_KO("Maximal cycles Reached");                                \
38    }                                                                   \
39/*cout << "SC_START (end  )" << endl;*/                                 \
40} while(0)
41
42void test (string name,
43           morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::reservation_station::Parameters * _param)
44{
45  cout << "<" << name << "> : Simulation SystemC" << endl;
46
47#ifdef STATISTICS
48  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
49#endif
50
51  Reservation_station * _Reservation_station = new Reservation_station (name.c_str(),
52#ifdef STATISTICS
53                                             _parameters_statistics,
54#endif
55                                             _param);
56 
57#ifdef SYSTEMC
58  /*********************************************************************
59   * Déclarations des signaux
60   *********************************************************************/
61  string rename = "";
62
63  sc_clock              * in_CLOCK  = new sc_clock ("clock", 1.0, 0.5);
64  sc_signal<Tcontrol_t> * in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
65
66  sc_signal<Tcontrol_t        > *  in_INSERT_VAL            = new sc_signal<Tcontrol_t        >;
67  sc_signal<Tcontrol_t        > * out_INSERT_ACK            = new sc_signal<Tcontrol_t        >;
68  sc_signal<Tcontext_t        > *  in_INSERT_CONTEXT_ID     = new sc_signal<Tcontext_t        >; 
69  sc_signal<Tcontext_t        > *  in_INSERT_FRONT_END_ID   = new sc_signal<Tcontext_t        >;
70  sc_signal<Tcontext_t        > *  in_INSERT_OOO_ENGINE_ID  = new sc_signal<Tcontext_t        >;
71  sc_signal<Tpacket_t         > *  in_INSERT_ROB_ID         = new sc_signal<Tpacket_t         >;
72  sc_signal<Toperation_t      > *  in_INSERT_OPERATION      = new sc_signal<Toperation_t      >;
73  sc_signal<Ttype_t           > *  in_INSERT_TYPE           = new sc_signal<Ttype_t           >;
74  sc_signal<Tcontrol_t        > *  in_INSERT_HAS_IMMEDIAT   = new sc_signal<Tcontrol_t        >;
75  sc_signal<Tgeneral_data_t   > *  in_INSERT_IMMEDIAT       = new sc_signal<Tgeneral_data_t   >;
76//sc_signal<Tcontrol_t        > *  in_INSERT_READ_RA        = new sc_signal<Tcontrol_t        >;
77  sc_signal<Tgeneral_address_t> *  in_INSERT_NUM_REG_RA     = new sc_signal<Tgeneral_address_t>;
78  sc_signal<Tcontrol_t        > *  in_INSERT_DATA_RA_VAL    = new sc_signal<Tcontrol_t        >;
79  sc_signal<Tgeneral_data_t   > *  in_INSERT_DATA_RA        = new sc_signal<Tgeneral_data_t   >;
80//sc_signal<Tcontrol_t        > *  in_INSERT_READ_RB        = new sc_signal<Tcontrol_t        >;
81  sc_signal<Tgeneral_address_t> *  in_INSERT_NUM_REG_RB     = new sc_signal<Tgeneral_address_t>;
82  sc_signal<Tcontrol_t        > *  in_INSERT_DATA_RB_VAL    = new sc_signal<Tcontrol_t        >;
83  sc_signal<Tgeneral_data_t   > *  in_INSERT_DATA_RB        = new sc_signal<Tgeneral_data_t   >;
84//sc_signal<Tcontrol_t        > *  in_INSERT_READ_RC        = new sc_signal<Tcontrol_t        >;
85  sc_signal<Tspecial_address_t> *  in_INSERT_NUM_REG_RC     = new sc_signal<Tspecial_address_t>;
86  sc_signal<Tcontrol_t        > *  in_INSERT_DATA_RC_VAL    = new sc_signal<Tcontrol_t        >;
87  sc_signal<Tspecial_data_t   > *  in_INSERT_DATA_RC        = new sc_signal<Tspecial_data_t   >;
88  sc_signal<Tcontrol_t        > *  in_INSERT_WRITE_RD       = new sc_signal<Tcontrol_t        >;
89  sc_signal<Tgeneral_address_t> *  in_INSERT_NUM_REG_RD     = new sc_signal<Tgeneral_address_t>;
90  sc_signal<Tcontrol_t        > *  in_INSERT_WRITE_RE       = new sc_signal<Tcontrol_t        >;
91  sc_signal<Tspecial_address_t> *  in_INSERT_NUM_REG_RE     = new sc_signal<Tspecial_address_t>;
92
93  sc_signal<Tcontrol_t        > ** out_RETIRE_VAL            = new sc_signal<Tcontrol_t        > * [_param->_nb_inst_retire];
94  sc_signal<Tcontrol_t        > **  in_RETIRE_ACK            = new sc_signal<Tcontrol_t        > * [_param->_nb_inst_retire];
95  sc_signal<Tcontext_t        > ** out_RETIRE_CONTEXT_ID     = new sc_signal<Tcontext_t        > * [_param->_nb_inst_retire];
96  sc_signal<Tcontext_t        > ** out_RETIRE_FRONT_END_ID   = new sc_signal<Tcontext_t        > * [_param->_nb_inst_retire];
97  sc_signal<Tcontext_t        > ** out_RETIRE_OOO_ENGINE_ID  = new sc_signal<Tcontext_t        > * [_param->_nb_inst_retire];
98  sc_signal<Tpacket_t         > ** out_RETIRE_ROB_ID         = new sc_signal<Tpacket_t         > * [_param->_nb_inst_retire];
99  sc_signal<Toperation_t      > ** out_RETIRE_OPERATION      = new sc_signal<Toperation_t      > * [_param->_nb_inst_retire];
100  sc_signal<Ttype_t           > ** out_RETIRE_TYPE           = new sc_signal<Ttype_t           > * [_param->_nb_inst_retire];
101  sc_signal<Tcontrol_t        > ** out_RETIRE_HAS_IMMEDIAT   = new sc_signal<Tcontrol_t        > * [_param->_nb_inst_retire];
102  sc_signal<Tgeneral_data_t   > ** out_RETIRE_IMMEDIAT       = new sc_signal<Tgeneral_data_t   > * [_param->_nb_inst_retire];
103  sc_signal<Tgeneral_data_t   > ** out_RETIRE_DATA_RA        = new sc_signal<Tgeneral_data_t   > * [_param->_nb_inst_retire];
104  sc_signal<Tgeneral_data_t   > ** out_RETIRE_DATA_RB        = new sc_signal<Tgeneral_data_t   > * [_param->_nb_inst_retire];
105  sc_signal<Tspecial_data_t   > ** out_RETIRE_DATA_RC        = new sc_signal<Tspecial_data_t   > * [_param->_nb_inst_retire];
106  sc_signal<Tcontrol_t        > ** out_RETIRE_WRITE_RD       = new sc_signal<Tcontrol_t        > * [_param->_nb_inst_retire];
107  sc_signal<Tgeneral_address_t> ** out_RETIRE_NUM_REG_RD     = new sc_signal<Tgeneral_address_t> * [_param->_nb_inst_retire];
108  sc_signal<Tcontrol_t        > ** out_RETIRE_WRITE_RE       = new sc_signal<Tcontrol_t        > * [_param->_nb_inst_retire];
109  sc_signal<Tspecial_address_t> ** out_RETIRE_NUM_REG_RE     = new sc_signal<Tspecial_address_t> * [_param->_nb_inst_retire];
110   
111  for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
112    {
113      out_RETIRE_VAL             [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
114       in_RETIRE_ACK             [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
115      out_RETIRE_CONTEXT_ID      [i] = new sc_signal<Tcontext_t        > (rename.c_str());
116      out_RETIRE_FRONT_END_ID    [i] = new sc_signal<Tcontext_t        > (rename.c_str());
117      out_RETIRE_OOO_ENGINE_ID   [i] = new sc_signal<Tcontext_t        > (rename.c_str());
118      out_RETIRE_ROB_ID          [i] = new sc_signal<Tpacket_t         > (rename.c_str());
119      out_RETIRE_OPERATION       [i] = new sc_signal<Toperation_t      > (rename.c_str());
120      out_RETIRE_TYPE            [i] = new sc_signal<Ttype_t           > (rename.c_str());
121      out_RETIRE_HAS_IMMEDIAT    [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
122      out_RETIRE_IMMEDIAT        [i] = new sc_signal<Tgeneral_data_t   > (rename.c_str());
123      out_RETIRE_DATA_RA         [i] = new sc_signal<Tgeneral_data_t   > (rename.c_str());
124      out_RETIRE_DATA_RB         [i] = new sc_signal<Tgeneral_data_t   > (rename.c_str());
125      out_RETIRE_DATA_RC         [i] = new sc_signal<Tspecial_data_t   > (rename.c_str());
126      out_RETIRE_WRITE_RD        [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
127      out_RETIRE_NUM_REG_RD      [i] = new sc_signal<Tgeneral_address_t> (rename.c_str());
128      out_RETIRE_WRITE_RE        [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
129      out_RETIRE_NUM_REG_RE      [i] = new sc_signal<Tspecial_address_t> (rename.c_str());
130    }
131
132  sc_signal<Tcontrol_t        > ** in_GPR_WRITE_VAL           = new sc_signal<Tcontrol_t        > * [_param->_nb_gpr_write];
133  sc_signal<Tcontext_t        > ** in_GPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t        > * [_param->_nb_gpr_write];
134  sc_signal<Tgeneral_address_t> ** in_GPR_WRITE_NUM_REG       = new sc_signal<Tgeneral_address_t> * [_param->_nb_gpr_write];
135  sc_signal<Tgeneral_data_t   > ** in_GPR_WRITE_DATA          = new sc_signal<Tgeneral_data_t   > * [_param->_nb_gpr_write];
136   
137  for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
138    {
139      in_GPR_WRITE_VAL           [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
140      in_GPR_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t        > (rename.c_str());
141      in_GPR_WRITE_NUM_REG       [i] = new sc_signal<Tgeneral_address_t> (rename.c_str());
142      in_GPR_WRITE_DATA          [i] = new sc_signal<Tgeneral_data_t   > (rename.c_str());
143    }
144 
145  sc_signal<Tcontrol_t        > ** in_SPR_WRITE_VAL          = new sc_signal<Tcontrol_t        > * [_param->_nb_spr_write];
146  sc_signal<Tcontext_t        > ** in_SPR_WRITE_OOO_ENGINE_ID= new sc_signal<Tcontext_t        > * [_param->_nb_spr_write];
147  sc_signal<Tspecial_address_t> ** in_SPR_WRITE_NUM_REG      = new sc_signal<Tspecial_address_t> * [_param->_nb_spr_write];
148  sc_signal<Tspecial_data_t   > ** in_SPR_WRITE_DATA         = new sc_signal<Tspecial_data_t   > * [_param->_nb_spr_write];
149   
150  for (uint32_t i=0; i<_param->_nb_spr_write; i++)
151    {
152      in_SPR_WRITE_VAL           [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
153      in_SPR_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t        > (rename.c_str());
154      in_SPR_WRITE_NUM_REG       [i] = new sc_signal<Tspecial_address_t> (rename.c_str());
155      in_SPR_WRITE_DATA          [i] = new sc_signal<Tspecial_data_t   > (rename.c_str());
156    }
157
158  sc_signal<Tcontext_t        > ** in_BYPASS_WRITE_OOO_ENGINE_ID  = new sc_signal<Tcontext_t        > * [_param->_nb_bypass_write];
159  sc_signal<Tcontrol_t        > ** in_BYPASS_WRITE_GPR_VAL        = new sc_signal<Tcontrol_t        > * [_param->_nb_bypass_write];
160  sc_signal<Tgeneral_address_t> ** in_BYPASS_WRITE_GPR_NUM_REG    = new sc_signal<Tgeneral_address_t> * [_param->_nb_bypass_write];
161  sc_signal<Tgeneral_data_t   > ** in_BYPASS_WRITE_GPR_DATA       = new sc_signal<Tgeneral_data_t   > * [_param->_nb_bypass_write];
162  sc_signal<Tcontrol_t        > ** in_BYPASS_WRITE_SPR_VAL        = new sc_signal<Tcontrol_t        > * [_param->_nb_bypass_write];
163  sc_signal<Tspecial_address_t> ** in_BYPASS_WRITE_SPR_NUM_REG    = new sc_signal<Tspecial_address_t> * [_param->_nb_bypass_write];
164  sc_signal<Tspecial_data_t   > ** in_BYPASS_WRITE_SPR_DATA       = new sc_signal<Tspecial_data_t   > * [_param->_nb_bypass_write];
165
166  for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
167    {
168      in_BYPASS_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t        > (rename.c_str());
169      in_BYPASS_WRITE_GPR_VAL       [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
170      in_BYPASS_WRITE_GPR_NUM_REG   [i] = new sc_signal<Tgeneral_address_t> (rename.c_str());
171      in_BYPASS_WRITE_GPR_DATA      [i] = new sc_signal<Tgeneral_data_t   > (rename.c_str());
172      in_BYPASS_WRITE_SPR_VAL       [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
173      in_BYPASS_WRITE_SPR_NUM_REG   [i] = new sc_signal<Tspecial_address_t> (rename.c_str());
174      in_BYPASS_WRITE_SPR_DATA      [i] = new sc_signal<Tspecial_data_t   > (rename.c_str());
175    }
176  sc_signal<Tcontrol_t        > ** in_BYPASS_MEMORY_VAL            = new sc_signal<Tcontrol_t        > * [_param->_nb_bypass_memory];
177  sc_signal<Tcontext_t        > ** in_BYPASS_MEMORY_OOO_ENGINE_ID  = new sc_signal<Tcontext_t        > * [_param->_nb_bypass_memory];
178  sc_signal<Tgeneral_address_t> ** in_BYPASS_MEMORY_NUM_REG        = new sc_signal<Tgeneral_address_t> * [_param->_nb_bypass_memory];
179  sc_signal<Tgeneral_data_t   > ** in_BYPASS_MEMORY_DATA           = new sc_signal<Tgeneral_data_t   > * [_param->_nb_bypass_memory];
180
181  for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
182    {
183      in_BYPASS_MEMORY_VAL           [i] = new sc_signal<Tcontrol_t        > (rename.c_str());
184      in_BYPASS_MEMORY_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t        > (rename.c_str());
185      in_BYPASS_MEMORY_NUM_REG       [i] = new sc_signal<Tgeneral_address_t> (rename.c_str());
186      in_BYPASS_MEMORY_DATA          [i] = new sc_signal<Tgeneral_data_t   > (rename.c_str());
187    }
188   
189  /********************************************************
190   * Instanciation
191   ********************************************************/
192 
193  cout << "<" << name << "> Instanciation of _Reservation_station" << endl;
194 
195  (*(_Reservation_station->in_CLOCK))        (*(in_CLOCK));
196  (*(_Reservation_station->in_NRESET))       (*(in_NRESET));
197
198  (*(_Reservation_station-> in_INSERT_VAL              )) (*( in_INSERT_VAL              ));
199  (*(_Reservation_station->out_INSERT_ACK              )) (*(out_INSERT_ACK              ));
200  if (_param->_have_port_context_id)
201  (*(_Reservation_station-> in_INSERT_CONTEXT_ID       )) (*( in_INSERT_CONTEXT_ID       ));
202  if (_param->_have_port_front_end_id)
203  (*(_Reservation_station-> in_INSERT_FRONT_END_ID     )) (*( in_INSERT_FRONT_END_ID     ));
204  if (_param->_have_port_ooo_engine_id)
205  (*(_Reservation_station-> in_INSERT_OOO_ENGINE_ID    )) (*( in_INSERT_OOO_ENGINE_ID    ));
206  if (_param->_have_port_rob_id)
207  (*(_Reservation_station-> in_INSERT_ROB_ID           )) (*( in_INSERT_ROB_ID           ));
208  (*(_Reservation_station-> in_INSERT_OPERATION        )) (*( in_INSERT_OPERATION        ));
209  (*(_Reservation_station-> in_INSERT_TYPE             )) (*( in_INSERT_TYPE             ));
210  (*(_Reservation_station-> in_INSERT_HAS_IMMEDIAT     )) (*( in_INSERT_HAS_IMMEDIAT     ));
211  (*(_Reservation_station-> in_INSERT_IMMEDIAT         )) (*( in_INSERT_IMMEDIAT         ));
212//   (*(_Reservation_station-> in_INSERT_READ_RA          )) (*( in_INSERT_READ_RA          ));
213  (*(_Reservation_station-> in_INSERT_NUM_REG_RA       )) (*( in_INSERT_NUM_REG_RA       ));
214  (*(_Reservation_station-> in_INSERT_DATA_RA_VAL      )) (*( in_INSERT_DATA_RA_VAL      ));
215  (*(_Reservation_station-> in_INSERT_DATA_RA          )) (*( in_INSERT_DATA_RA          ));
216//   (*(_Reservation_station-> in_INSERT_READ_RB          )) (*( in_INSERT_READ_RB          ));
217  (*(_Reservation_station-> in_INSERT_NUM_REG_RB       )) (*( in_INSERT_NUM_REG_RB       ));
218  (*(_Reservation_station-> in_INSERT_DATA_RB_VAL      )) (*( in_INSERT_DATA_RB_VAL      ));
219  (*(_Reservation_station-> in_INSERT_DATA_RB          )) (*( in_INSERT_DATA_RB          ));
220//   (*(_Reservation_station-> in_INSERT_READ_RC          )) (*( in_INSERT_READ_RC          ));
221  (*(_Reservation_station-> in_INSERT_NUM_REG_RC       )) (*( in_INSERT_NUM_REG_RC       ));
222  (*(_Reservation_station-> in_INSERT_DATA_RC_VAL      )) (*( in_INSERT_DATA_RC_VAL      ));
223  (*(_Reservation_station-> in_INSERT_DATA_RC          )) (*( in_INSERT_DATA_RC          ));
224  (*(_Reservation_station-> in_INSERT_WRITE_RD         )) (*( in_INSERT_WRITE_RD         ));
225  (*(_Reservation_station-> in_INSERT_NUM_REG_RD       )) (*( in_INSERT_NUM_REG_RD       ));
226  (*(_Reservation_station-> in_INSERT_WRITE_RE         )) (*( in_INSERT_WRITE_RE         ));
227  (*(_Reservation_station-> in_INSERT_NUM_REG_RE       )) (*( in_INSERT_NUM_REG_RE       ));
228
229    for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
230      {
231  (*(_Reservation_station->out_RETIRE_VAL            [i])) (*(out_RETIRE_VAL            [i]));
232  (*(_Reservation_station-> in_RETIRE_ACK            [i])) (*( in_RETIRE_ACK            [i]));
233  if (_param->_have_port_context_id)
234  (*(_Reservation_station->out_RETIRE_CONTEXT_ID     [i])) (*(out_RETIRE_CONTEXT_ID     [i]));
235  if (_param->_have_port_front_end_id)
236  (*(_Reservation_station->out_RETIRE_FRONT_END_ID   [i])) (*(out_RETIRE_FRONT_END_ID   [i]));
237  if (_param->_have_port_ooo_engine_id)
238  (*(_Reservation_station->out_RETIRE_OOO_ENGINE_ID  [i])) (*(out_RETIRE_OOO_ENGINE_ID  [i]));
239  if (_param->_have_port_rob_id)
240  (*(_Reservation_station->out_RETIRE_ROB_ID         [i])) (*(out_RETIRE_ROB_ID         [i]));
241  (*(_Reservation_station->out_RETIRE_OPERATION      [i])) (*(out_RETIRE_OPERATION      [i]));
242  (*(_Reservation_station->out_RETIRE_TYPE           [i])) (*(out_RETIRE_TYPE           [i]));
243  (*(_Reservation_station->out_RETIRE_HAS_IMMEDIAT   [i])) (*(out_RETIRE_HAS_IMMEDIAT   [i]));
244  (*(_Reservation_station->out_RETIRE_IMMEDIAT       [i])) (*(out_RETIRE_IMMEDIAT       [i]));
245  (*(_Reservation_station->out_RETIRE_DATA_RA        [i])) (*(out_RETIRE_DATA_RA        [i]));
246  (*(_Reservation_station->out_RETIRE_DATA_RB        [i])) (*(out_RETIRE_DATA_RB        [i]));
247  (*(_Reservation_station->out_RETIRE_DATA_RC        [i])) (*(out_RETIRE_DATA_RC        [i]));
248  (*(_Reservation_station->out_RETIRE_WRITE_RD       [i])) (*(out_RETIRE_WRITE_RD       [i]));
249  (*(_Reservation_station->out_RETIRE_NUM_REG_RD     [i])) (*(out_RETIRE_NUM_REG_RD     [i]));
250  (*(_Reservation_station->out_RETIRE_WRITE_RE       [i])) (*(out_RETIRE_WRITE_RE       [i]));
251  (*(_Reservation_station->out_RETIRE_NUM_REG_RE     [i])) (*(out_RETIRE_NUM_REG_RE     [i]));
252      }
253    for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
254      {
255  (*(_Reservation_station-> in_GPR_WRITE_VAL                        [i])) (*( in_GPR_WRITE_VAL                        [i]));
256  if (_param->_have_port_ooo_engine_id)
257  (*(_Reservation_station-> in_GPR_WRITE_OOO_ENGINE_ID              [i])) (*( in_GPR_WRITE_OOO_ENGINE_ID              [i]));
258  (*(_Reservation_station-> in_GPR_WRITE_NUM_REG                    [i])) (*( in_GPR_WRITE_NUM_REG                    [i]));
259  (*(_Reservation_station-> in_GPR_WRITE_DATA                       [i])) (*( in_GPR_WRITE_DATA                       [i]));
260      }
261    for (uint32_t i=0; i<_param->_nb_spr_write; i++)
262      {
263  (*(_Reservation_station-> in_SPR_WRITE_VAL                        [i])) (*( in_SPR_WRITE_VAL                        [i]));
264  if (_param->_have_port_ooo_engine_id)
265  (*(_Reservation_station-> in_SPR_WRITE_OOO_ENGINE_ID              [i])) (*( in_SPR_WRITE_OOO_ENGINE_ID              [i]));
266  (*(_Reservation_station-> in_SPR_WRITE_NUM_REG                    [i])) (*( in_SPR_WRITE_NUM_REG                    [i]));
267  (*(_Reservation_station-> in_SPR_WRITE_DATA                       [i])) (*( in_SPR_WRITE_DATA                       [i]));
268      }
269    for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
270      {
271  if (_param->_have_port_ooo_engine_id)
272  (*(_Reservation_station-> in_BYPASS_WRITE_OOO_ENGINE_ID           [i])) (*( in_BYPASS_WRITE_OOO_ENGINE_ID           [i]));
273  (*(_Reservation_station-> in_BYPASS_WRITE_GPR_VAL                 [i])) (*( in_BYPASS_WRITE_GPR_VAL                 [i]));
274  (*(_Reservation_station-> in_BYPASS_WRITE_GPR_NUM_REG             [i])) (*( in_BYPASS_WRITE_GPR_NUM_REG             [i]));
275  (*(_Reservation_station-> in_BYPASS_WRITE_GPR_DATA                [i])) (*( in_BYPASS_WRITE_GPR_DATA                [i]));
276  (*(_Reservation_station-> in_BYPASS_WRITE_SPR_VAL                 [i])) (*( in_BYPASS_WRITE_SPR_VAL                 [i]));
277  (*(_Reservation_station-> in_BYPASS_WRITE_SPR_NUM_REG             [i])) (*( in_BYPASS_WRITE_SPR_NUM_REG             [i]));
278  (*(_Reservation_station-> in_BYPASS_WRITE_SPR_DATA                [i])) (*( in_BYPASS_WRITE_SPR_DATA                [i]));
279      }
280    for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
281      {
282  (*(_Reservation_station-> in_BYPASS_MEMORY_VAL                    [i])) (*( in_BYPASS_MEMORY_VAL                    [i]));
283  if (_param->_have_port_ooo_engine_id)
284  (*(_Reservation_station-> in_BYPASS_MEMORY_OOO_ENGINE_ID          [i])) (*( in_BYPASS_MEMORY_OOO_ENGINE_ID          [i]));
285  (*(_Reservation_station-> in_BYPASS_MEMORY_NUM_REG                [i])) (*( in_BYPASS_MEMORY_NUM_REG                [i]));
286  (*(_Reservation_station-> in_BYPASS_MEMORY_DATA                   [i])) (*( in_BYPASS_MEMORY_DATA                   [i]));
287      }
288
289  cout << "<" << name << "> Start Simulation ............" << endl;
290  Time * _time = new Time();
291
292  /********************************************************
293   * Simulation - Begin
294   ********************************************************/
295
296  // Initialisation
297
298  const uint32_t nb_request = _param->_nb_packet;
299  const uint32_t seed = 0;
300//const uint32_t seed = static_cast<uint32_t>(time(NULL));
301  srand(seed);
302
303  Tcontext_t         _ooo_engine_id [nb_request];
304  Tcontrol_t         _read_ra    [nb_request];
305  Tgeneral_address_t _num_reg_ra [nb_request];
306  Tcontrol_t         _read_rb    [nb_request];
307  Tgeneral_address_t _num_reg_rb [nb_request];
308  Tcontrol_t         _read_rc    [nb_request];
309  Tspecial_address_t _num_reg_rc [nb_request];
310
311  // emulation of registerFile
312  Tcontrol_t         _gpr_val    [_param->_nb_general_register][_param->_nb_ooo_engine];
313  Tgeneral_data_t    _gpr        [_param->_nb_general_register][_param->_nb_ooo_engine];
314  Tcontrol_t         _spr_val    [_param->_nb_special_register][_param->_nb_ooo_engine];
315  Tspecial_data_t    _spr        [_param->_nb_special_register][_param->_nb_ooo_engine];
316
317  SC_START(0);
318
319  LABEL("Initialisation");
320  in_INSERT_VAL ->write(0);
321  for (uint32_t i=0; i<_param->_nb_inst_retire  ; i++)
322    in_RETIRE_ACK [i]->write(0);
323  for (uint32_t i=0; i<_param->_nb_gpr_write    ; i++)
324    in_GPR_WRITE_VAL               [i]->write(0);
325  for (uint32_t i=0; i<_param->_nb_spr_write    ; i++)
326    in_SPR_WRITE_VAL               [i]->write(0);
327  for (uint32_t i=0; i<_param->_nb_bypass_write ; i++)
328    {
329      in_BYPASS_WRITE_GPR_VAL      [i]->write(0);
330      in_BYPASS_WRITE_SPR_VAL      [i]->write(0);
331    }
332  for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
333    in_BYPASS_MEMORY_VAL           [i]->write(0);
334
335  in_NRESET->write(0);
336  SC_START(5);
337  in_NRESET->write(1);
338
339  LABEL("Loop of Test");
340
341  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
342    {
343      LABEL("Iteration "+toString(iteration));
344
345      int32_t percent_transaction_queue_in     = (rand()%50)+25;
346      int32_t percent_transaction_queue_out    = (rand()%50)+25;
347      int32_t percent_registerfile_valid       = (rand()%50)+25;
348      int32_t percent_transaction_registerfile = (rand()%50)+25;
349      int32_t percent_transaction_bypass       = (rand()%50)+25;
350     
351      LABEL("Initialisation");
352
353      for (uint32_t i=0; i<nb_request; i++)
354        {
355          _ooo_engine_id   [i] = rand()% _param->_nb_ooo_engine            ;
356          _read_ra      [i] = rand()% 2                              ;
357          _num_reg_ra   [i] = rand()% _param->_nb_general_register   ;
358          _read_rb      [i] = rand()% 2                              ;
359          _num_reg_rb   [i] = rand()% _param->_nb_general_register   ;
360          _read_rc      [i] = rand()% 2                              ;
361          _num_reg_rc   [i] = rand()% _param->_nb_special_register   ;
362        }
363     
364      // emulation of registerFile
365      for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
366        {
367          for (uint32_t i=0; i<_param->_nb_general_register; i++)
368            {
369              _gpr_val      [i][j] = ((rand()%100) < percent_registerfile_valid);
370              _gpr          [i][j] = rand()%((1<<_param->_size_general_data)-1);
371            }
372          for (uint32_t i=0; i<_param->_nb_special_register; i++)
373            {
374              _spr_val      [i][j] = ((rand()%100) < percent_registerfile_valid);
375              _spr          [i][j] = rand()%(1<<_param->_size_special_data);
376            }
377        }
378      // End initialisation .......
379
380      uint32_t request_in  = 0;
381      uint32_t request_out = 0;
382      bool     request_out_wait [nb_request];
383
384      for (uint32_t i=0; i<nb_request; i++)
385        request_out_wait [i] = true;
386     
387      bool can_gpr_use [_param->_nb_ooo_engine][_param->_nb_general_register];
388      bool can_spr_use [_param->_nb_ooo_engine][_param->_nb_special_register];
389      bool need_gpr    [_param->_nb_ooo_engine][_param->_nb_general_register];
390      bool need_spr    [_param->_nb_ooo_engine][_param->_nb_special_register];
391
392     
393      for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
394        {
395          for (uint32_t i=0; i<_param->_nb_general_register; i++)
396            need_gpr [j][i] = false;
397          for (uint32_t i=0; i<_param->_nb_special_register; i++)
398            need_spr [j][i] = false;
399        }
400
401      while (request_out < nb_request)
402        {
403          for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
404            {
405              for (uint32_t i=0; i<_param->_nb_general_register; i++)
406                can_gpr_use [j][i] = true;
407              for (uint32_t i=0; i<_param->_nb_special_register; i++)
408                can_spr_use [j][i] = true;
409            }
410
411          Tcontrol_t         insert_val = (request_in < nb_request) and ((rand()%100) < percent_transaction_queue_in);
412          Tcontext_t         insert_ooo_engine_id;
413          Tgeneral_address_t insert_num_reg_ra;
414          Tgeneral_address_t insert_num_reg_rb;
415          Tspecial_address_t insert_num_reg_rc;
416
417          in_INSERT_VAL         ->write(insert_val);
418          if (insert_val)
419            {
420              bool               data_val;
421              insert_ooo_engine_id = _ooo_engine_id [request_in];
422              insert_num_reg_ra    = _num_reg_ra [request_in];
423              insert_num_reg_rb    = _num_reg_rb [request_in];
424              insert_num_reg_rc    = _num_reg_rc [request_in];
425
426              if (_param->_have_port_context_id)
427              in_INSERT_CONTEXT_ID     ->write((2*insert_ooo_engine_id)%_param->_nb_context  );
428              if (_param->_have_port_front_end_id)
429              in_INSERT_FRONT_END_ID   ->write((3*insert_ooo_engine_id)%_param->_nb_front_end);
430              if (_param->_have_port_ooo_engine_id)
431              in_INSERT_OOO_ENGINE_ID  ->write(insert_ooo_engine_id);
432              if (_param->_have_port_rob_id)
433              in_INSERT_ROB_ID      ->write(request_in);
434              in_INSERT_OPERATION   ->write(0);
435              in_INSERT_TYPE        ->write(0);
436              in_INSERT_HAS_IMMEDIAT->write(0);
437              in_INSERT_IMMEDIAT    ->write(0);
438//            in_INSERT_READ_RA     ->write(_read_ra[request_in]);
439              data_val = not(_read_ra[request_in]) or _gpr_val[insert_num_reg_ra][insert_ooo_engine_id];
440
441              need_gpr [insert_ooo_engine_id][insert_num_reg_ra] |= not data_val;
442
443              in_INSERT_NUM_REG_RA  ->write(insert_num_reg_ra);
444              in_INSERT_DATA_RA_VAL ->write(data_val);
445              in_INSERT_DATA_RA     ->write((data_val)?_gpr[insert_num_reg_ra][insert_ooo_engine_id]:0);
446//            in_INSERT_READ_RB     ->write(_read_rb[request_in]);
447              data_val = not(_read_rb[request_in]) or _gpr_val[insert_num_reg_rb][insert_ooo_engine_id];
448
449              need_gpr [insert_ooo_engine_id][insert_num_reg_rb] |= not data_val;
450
451              in_INSERT_NUM_REG_RB  ->write(insert_num_reg_rb);                       
452              in_INSERT_DATA_RB_VAL ->write(data_val);                         
453              in_INSERT_DATA_RB     ->write((data_val)?_gpr[insert_num_reg_rb][insert_ooo_engine_id]:0);
454//            in_INSERT_READ_RC     ->write(_read_rc[request_in]);
455              data_val = not(_read_rc[request_in]) or _spr_val[insert_num_reg_rc][insert_ooo_engine_id];
456
457              need_spr [insert_ooo_engine_id][insert_num_reg_rc] |= not data_val;
458
459              in_INSERT_NUM_REG_RC  ->write(insert_num_reg_rc);                       
460              in_INSERT_DATA_RC_VAL ->write(data_val);                         
461              in_INSERT_DATA_RC     ->write((data_val)?_spr[insert_num_reg_rc][insert_ooo_engine_id]:0);
462              in_INSERT_WRITE_RD    ->write(0);
463              in_INSERT_NUM_REG_RD  ->write(0);
464              in_INSERT_WRITE_RE    ->write(0);
465              in_INSERT_NUM_REG_RE  ->write(0);
466
467              can_gpr_use [insert_ooo_engine_id][insert_num_reg_ra] = false;
468              can_gpr_use [insert_ooo_engine_id][insert_num_reg_rb] = false;
469              can_spr_use [insert_ooo_engine_id][insert_num_reg_rc] = false;
470            }
471                 
472          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
473            in_RETIRE_ACK[i]->write((rand()%100)<percent_transaction_queue_out);
474
475          LABEL("Bypass Network :");
476          for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
477            {
478              Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
479              Tcontext_t         ooo_engine = rand()% _param->_nb_ooo_engine;
480              Tcontrol_t         val     = (_gpr_val [num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_registerfile):0;
481              Tgeneral_data_t    data    = rand()%((1<<_param->_size_general_data)-1);
482           
483              val = (val and can_gpr_use [ooo_engine][num_reg] and need_gpr [ooo_engine][num_reg]);
484
485              in_GPR_WRITE_VAL            [i]->write(val);           
486              if (_param->_have_port_ooo_engine_id)
487              in_GPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
488              in_GPR_WRITE_NUM_REG        [i]->write(num_reg);
489              in_GPR_WRITE_DATA           [i]->write(data);
490
491              if (val)
492                {
493                  LABEL(" * GPR_WRITE     ["+toString(i)+"] - gpr["+toString(num_reg)+"]["+toString(ooo_engine)+"] <- "+toString(data));
494                  can_gpr_use [ooo_engine][num_reg] = false;
495                  need_gpr [ooo_engine][num_reg]    = false;
496
497
498                  _gpr     [num_reg][ooo_engine] = data;
499                  _gpr_val [num_reg][ooo_engine] = 1;
500                }
501            }
502          for (uint32_t i=0; i<_param->_nb_spr_write; i++)
503            {
504              Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
505              Tcontext_t         ooo_engine = rand()% _param->_nb_ooo_engine;
506              Tcontrol_t         val     = (_spr_val [num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_registerfile):0;
507              Tspecial_data_t    data    = rand()%(1<<_param->_size_special_data);
508
509              val = (val and can_spr_use [ooo_engine][num_reg] and need_spr[ooo_engine][num_reg]);
510
511              in_SPR_WRITE_VAL            [i]->write(val);           
512              if (_param->_have_port_ooo_engine_id)
513              in_SPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
514              in_SPR_WRITE_NUM_REG        [i]->write(num_reg);
515              in_SPR_WRITE_DATA           [i]->write(data);
516
517              if (val == 1)
518                {
519                  LABEL(" * SPR_WRITE     ["+toString(i)+"] - spr["+toString(num_reg)+"]["+toString(ooo_engine)+"] <- "+toString(data));
520                  can_spr_use [ooo_engine][num_reg] = false;
521                  need_spr[ooo_engine][num_reg]     = false;
522
523                  _spr     [num_reg][ooo_engine] = data;
524                  _spr_val [num_reg][ooo_engine] = 1;
525                }
526            }
527
528          for (uint32_t i=0; i<_param->_nb_bypass_write; i++)
529            {
530              Tcontext_t         ooo_engine     = rand()% _param->_nb_ooo_engine;
531              if (_param->_have_port_ooo_engine_id)
532              in_BYPASS_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
533
534              Tgeneral_address_t gpr_num_reg = rand()% _param->_nb_general_register;
535              Tcontrol_t         gpr_val     = (_gpr_val [gpr_num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_bypass):0;
536              Tgeneral_data_t    gpr_data    = rand()%((1<<_param->_size_general_data)-1);
537             
538              gpr_val = (gpr_val and can_gpr_use [ooo_engine][gpr_num_reg] and need_gpr[ooo_engine][gpr_num_reg]);
539
540              in_BYPASS_WRITE_GPR_VAL    [i]->write(gpr_val);         
541              in_BYPASS_WRITE_GPR_NUM_REG[i]->write(gpr_num_reg);
542              in_BYPASS_WRITE_GPR_DATA   [i]->write(gpr_data);
543
544              if (gpr_val)
545                {
546                  LABEL(" * BYPASS_WRITE  ["+toString(i)+"] - gpr["+toString(gpr_num_reg)+"]["+toString(ooo_engine)+"] <- "+toString(gpr_data));
547                  can_gpr_use [ooo_engine][gpr_num_reg] = false;
548                  need_gpr[ooo_engine][gpr_num_reg]     = false;
549
550                  _gpr     [gpr_num_reg][ooo_engine] = gpr_data;
551                  _gpr_val [gpr_num_reg][ooo_engine] = 1;
552                }
553
554              Tspecial_address_t spr_num_reg = rand()% _param->_nb_special_register;
555              Tcontrol_t         spr_val     = (_spr_val [spr_num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_bypass):0;
556              Tspecial_data_t    spr_data    = rand()%(1<<_param->_size_special_data);
557             
558              spr_val = (spr_val and can_spr_use [ooo_engine][spr_num_reg] and need_spr[ooo_engine][spr_num_reg]);
559
560              in_BYPASS_WRITE_SPR_VAL    [i]->write(spr_val);         
561              in_BYPASS_WRITE_SPR_NUM_REG[i]->write(spr_num_reg);
562              in_BYPASS_WRITE_SPR_DATA   [i]->write(spr_data);
563
564              if (spr_val)
565                {
566                  LABEL(" * BYPASS_WRITE  ["+toString(i)+"] - spr["+toString(spr_num_reg)+"]["+toString(ooo_engine)+"] <- "+toString(spr_data));
567                  can_spr_use [ooo_engine][spr_num_reg] = false;
568                  need_spr[ooo_engine][spr_num_reg]     = false;
569
570                  _spr     [spr_num_reg][ooo_engine] = spr_data;
571                  _spr_val [spr_num_reg][ooo_engine] = 1;
572                }
573
574            }
575
576          for (uint32_t i=0; i<_param->_nb_bypass_memory; i++)
577            {
578              Tcontext_t         ooo_engine     = rand()% _param->_nb_ooo_engine;
579              if (_param->_have_port_ooo_engine_id)
580              in_BYPASS_MEMORY_OOO_ENGINE_ID [i]->write(ooo_engine);
581
582              Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
583              Tcontrol_t         val     = (_gpr_val [num_reg][ooo_engine]== 0)?((rand()%100) < percent_transaction_bypass):0;
584              Tgeneral_data_t    data    = rand()%((1<<_param->_size_general_data)-1);
585             
586              val = (val and can_gpr_use [ooo_engine][num_reg] and need_gpr [ooo_engine][num_reg]);
587
588              in_BYPASS_MEMORY_VAL    [i]->write(val);       
589              in_BYPASS_MEMORY_NUM_REG[i]->write(num_reg);
590              in_BYPASS_MEMORY_DATA   [i]->write(data);
591
592              if (val)
593                {
594                  LABEL(" * BYPASS_MEMORY ["+toString(i)+"] - gpr["+toString(num_reg)+"]["+toString(ooo_engine)+"] <- "+toString(data));
595                  can_gpr_use [ooo_engine][num_reg] = false;
596                  need_gpr [ooo_engine][num_reg] = false;
597
598                  _gpr     [num_reg][ooo_engine] = data;
599                  _gpr_val [num_reg][ooo_engine] = 1;
600                }
601            }
602          SC_START(0); // to mealy function
603         
604//        LABEL("Test     INSERT  : "+toString(in_INSERT_VAL->read())+","+toString(out_INSERT_ACK->read()));
605          if (( in_INSERT_VAL->read() == 1) and
606              (out_INSERT_ACK->read() == 1))
607            {
608              LABEL("Accepted INSERT  number : "+toString(request_in));
609              request_in  ++;
610            }
611
612          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
613            {
614              LABEL("Test     RETIRE "+toString(i)+" : "+toString(out_RETIRE_VAL[i]->read())+","+toString(in_RETIRE_ACK[i]->read()));
615              if ((out_RETIRE_VAL [i]->read() == 1) and
616                  ( in_RETIRE_ACK [i]->read() == 1))
617                {
618                  Tpacket_t  rob_id;
619                  if (_param->_have_port_rob_id)
620                    rob_id = out_RETIRE_ROB_ID [i]->read();
621                  else
622                    rob_id = 0;
623                  LABEL("Accepted RETIRE ["+toString(i)+"] number : "+toString(rob_id)+", request number : "+toString(request_out));
624                  TEST(bool, request_out_wait [rob_id] , true);
625
626                  request_out ++;
627                  request_out_wait [rob_id] = false;
628
629                  Tcontext_t ooo_engine_id = _ooo_engine_id [rob_id];
630                 
631                  if (_param->_have_port_context_id)
632                  TEST(Tcontext_t        ,out_RETIRE_CONTEXT_ID   [i]->read(),(2*ooo_engine_id)%_param->_nb_context  );
633                  if (_param->_have_port_front_end_id)
634                  TEST(Tcontext_t        ,out_RETIRE_FRONT_END_ID [i]->read(),(3*ooo_engine_id)%_param->_nb_front_end);
635                  if (_param->_have_port_ooo_engine_id)
636                  TEST(Tcontext_t        ,out_RETIRE_OOO_ENGINE_ID[i]->read(),ooo_engine_id);
637
638                  if (_read_ra [rob_id])
639                  TEST(Tgeneral_data_t   ,out_RETIRE_DATA_RA   [i]->read(),_gpr[_num_reg_ra[rob_id]][ooo_engine_id]);
640                 
641                  if (_read_rb [rob_id])
642                  TEST(Tgeneral_data_t   ,out_RETIRE_DATA_RB   [i]->read(),_gpr[_num_reg_rb[rob_id]][ooo_engine_id]);
643                 
644                  if (_read_rc [rob_id])
645                  TEST(Tspecial_data_t   ,out_RETIRE_DATA_RC   [i]->read(),_spr[_num_reg_rc[rob_id]][ooo_engine_id]);
646
647//                need_gpr [ooo_engine_id][_num_reg_ra[rob_id]]= true;
648//                need_gpr [ooo_engine_id][_num_reg_rb[rob_id]]= true;
649//                need_spr [ooo_engine_id][_num_reg_rc[rob_id]]= true;
650                }
651            }
652         
653          SC_START(1);   
654        }
655    }
656
657  /********************************************************
658   * Simulation - End
659   ********************************************************/
660
661  TEST_OK ("End of Simulation");
662  delete _time;
663  cout << "<" << name << "> ............ Stop Simulation" << endl;
664
665  delete     in_CLOCK ;
666  delete     in_NRESET;
667
668  delete     in_INSERT_VAL         ;
669  delete    out_INSERT_ACK         ;
670  if (_param->_have_port_context_id) 
671  delete     in_INSERT_CONTEXT_ID  ;
672  if (_param->_have_port_front_end_id) 
673  delete     in_INSERT_FRONT_END_ID   ;
674  if (_param->_have_port_ooo_engine_id) 
675  delete     in_INSERT_OOO_ENGINE_ID  ;
676  if (_param->_have_port_rob_id) 
677  delete     in_INSERT_ROB_ID      ;
678  delete     in_INSERT_OPERATION   ;
679  delete     in_INSERT_TYPE        ;
680  delete     in_INSERT_HAS_IMMEDIAT;
681  delete     in_INSERT_IMMEDIAT    ;
682//delete     in_INSERT_READ_RA     ;
683  delete     in_INSERT_NUM_REG_RA  ;
684  delete     in_INSERT_DATA_RA_VAL ;
685  delete     in_INSERT_DATA_RA     ;
686//delete     in_INSERT_READ_RB     ;
687  delete     in_INSERT_NUM_REG_RB  ;
688  delete     in_INSERT_DATA_RB_VAL ;
689  delete     in_INSERT_DATA_RB     ;
690//delete     in_INSERT_READ_RC     ;
691  delete     in_INSERT_NUM_REG_RC  ;
692  delete     in_INSERT_DATA_RC_VAL ;
693  delete     in_INSERT_DATA_RC     ;
694  delete     in_INSERT_WRITE_RD    ;
695  delete     in_INSERT_NUM_REG_RD  ;
696  delete     in_INSERT_WRITE_RE    ;
697  delete     in_INSERT_NUM_REG_RE  ;
698 
699  delete [] out_RETIRE_VAL         ;
700  delete []  in_RETIRE_ACK         ;
701  if (_param->_have_port_context_id) 
702  delete [] out_RETIRE_CONTEXT_ID  ;
703  if (_param->_have_port_front_end_id) 
704  delete [] out_RETIRE_FRONT_END_ID;
705  if (_param->_have_port_ooo_engine_id) 
706  delete [] out_RETIRE_OOO_ENGINE_ID  ;
707  if (_param->_have_port_rob_id) 
708  delete [] out_RETIRE_ROB_ID   ;
709  delete [] out_RETIRE_OPERATION   ;
710  delete [] out_RETIRE_TYPE        ;
711  delete [] out_RETIRE_HAS_IMMEDIAT;
712  delete [] out_RETIRE_IMMEDIAT    ;
713  delete [] out_RETIRE_DATA_RA     ;
714  delete [] out_RETIRE_DATA_RB     ;
715  delete [] out_RETIRE_DATA_RC     ;
716  delete [] out_RETIRE_WRITE_RD    ;
717  delete [] out_RETIRE_NUM_REG_RD  ;
718  delete [] out_RETIRE_WRITE_RE    ;
719  delete [] out_RETIRE_NUM_REG_RE  ;
720 
721  delete []  in_GPR_WRITE_VAL       ;
722  if (_param->_have_port_ooo_engine_id) 
723  delete []  in_GPR_WRITE_OOO_ENGINE_ID;
724  delete []  in_GPR_WRITE_NUM_REG   ;
725  delete []  in_GPR_WRITE_DATA      ;
726 
727  delete []  in_SPR_WRITE_VAL       ;
728  if (_param->_have_port_ooo_engine_id) 
729  delete []  in_SPR_WRITE_OOO_ENGINE_ID;
730  delete []  in_SPR_WRITE_NUM_REG   ;
731  delete []  in_SPR_WRITE_DATA      ;
732 
733  if (_param->_have_port_ooo_engine_id) 
734  delete []  in_BYPASS_WRITE_OOO_ENGINE_ID ;
735  delete []  in_BYPASS_WRITE_GPR_VAL    ;
736  delete []  in_BYPASS_WRITE_GPR_NUM_REG;
737  delete []  in_BYPASS_WRITE_GPR_DATA   ;
738  delete []  in_BYPASS_WRITE_SPR_VAL    ;
739  delete []  in_BYPASS_WRITE_SPR_NUM_REG;
740  delete []  in_BYPASS_WRITE_SPR_DATA   ;
741 
742  delete []  in_BYPASS_MEMORY_VAL       ;
743  if (_param->_have_port_ooo_engine_id) 
744  delete []  in_BYPASS_MEMORY_OOO_ENGINE_ID;
745  delete []  in_BYPASS_MEMORY_NUM_REG   ;
746  delete []  in_BYPASS_MEMORY_DATA      ;
747#endif
748
749  delete _Reservation_station;
750#ifdef STATISTICS
751  delete _parameters_statistics;
752#endif
753}
Note: See TracBrowser for help on using the repository browser.