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

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