source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/SelfTest/src/test.cpp @ 117

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

1) Platforms : add new organization for test
2) Load_Store_Unit : add array to count nb_check in store_queue
3) Issue_queue and Core_Glue : rewrite the issue network
4) Special_Register_Unit : add reset value to register CID
5) Softwares : add multicontext test
6) Softwares : add SPECINT
7) Softwares : add MiBench?
7) Read_queue : inhib access for r0
8) Change Core_Glue (network) - dont yet support priority and load balancing scheme
  • Property svn:keywords set to Id
File size: 36.1 KB
Line 
1/*
2 * $Id: test.cpp 117 2009-05-16 14:42:39Z rosiere $
3 *
4 * [ Description ]
5 *
6 * Test
7 */
8
9#define NB_ITERATION  1
10#define CYCLE_MAX     (128*NB_ITERATION)
11
12#include "Behavioural/Core/Multi_OOO_Engine/OOO_Engine/Rename_unit/Register_translation_unit/Stat_List_unit/SelfTest/include/test.h"
13#include "Common/include/Test.h"
14#include "Behavioural/include/Allocation.h"
15#include <list>
16
17
18class entry_t
19{
20public : bool     _is_free ;
21public : bool     _is_link ;
22public : bool     _is_valid;
23public : uint32_t _counter ;
24};
25
26
27void test (string name,
28           morpheo::behavioural::core::multi_ooo_engine::ooo_engine::rename_unit::register_translation_unit::stat_list_unit::Parameters * _param)
29{
30  msg(_("<%s> : Simulation SystemC.\n"),name.c_str());
31
32#ifdef STATISTICS
33  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
34#endif
35
36  Tusage_t _usage = USE_ALL;
37
38//   _usage = usage_unset(_usage,USE_SYSTEMC              );
39//   _usage = usage_unset(_usage,USE_VHDL                 );
40//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
41//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
42//   _usage = usage_unset(_usage,USE_POSITION             );
43//   _usage = usage_unset(_usage,USE_STATISTICS           );
44//   _usage = usage_unset(_usage,USE_INFORMATION          );
45
46  Stat_List_unit * _Stat_List_unit = new Stat_List_unit
47    (name.c_str(),
48#ifdef STATISTICS
49     _parameters_statistics,
50#endif
51     _param,
52     _usage);
53 
54#ifdef SYSTEMC
55  /*********************************************************************
56   * Déclarations des signaux
57   *********************************************************************/
58  string rename;
59
60  sc_clock              *  in_CLOCK  = new sc_clock ("clock", 1.0, 0.5);         
61  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
62
63  sc_signal<Tcontrol_t        >   **  in_INSERT_VAL               ;//[nb_inst_insert]
64  sc_signal<Tcontrol_t        >   ** out_INSERT_ACK               ;//[nb_inst_insert]
65//sc_signal<Tcontrol_t        >   **  in_INSERT_READ_RA           ;//[nb_inst_insert]
66//sc_signal<Tgeneral_address_t>   **  in_INSERT_NUM_REG_RA_PHY    ;//[nb_inst_insert]
67//sc_signal<Tcontrol_t        >   **  in_INSERT_READ_RB           ;//[nb_inst_insert]
68//sc_signal<Tgeneral_address_t>   **  in_INSERT_NUM_REG_RB_PHY    ;//[nb_inst_insert]
69//sc_signal<Tcontrol_t        >   **  in_INSERT_READ_RC           ;//[nb_inst_insert]
70//sc_signal<Tspecial_address_t>   **  in_INSERT_NUM_REG_RC_PHY    ;//[nb_inst_insert]
71  sc_signal<Tcontrol_t        >   **  in_INSERT_WRITE_RD          ;//[nb_inst_insert]
72  sc_signal<Tgeneral_address_t>   **  in_INSERT_NUM_REG_RD_PHY_OLD;//[nb_inst_insert]
73  sc_signal<Tgeneral_address_t>   **  in_INSERT_NUM_REG_RD_PHY_NEW;//[nb_inst_insert]
74  sc_signal<Tcontrol_t        >   **  in_INSERT_WRITE_RE          ;//[nb_inst_insert]
75  sc_signal<Tspecial_address_t>   **  in_INSERT_NUM_REG_RE_PHY_OLD;//[nb_inst_insert]
76  sc_signal<Tspecial_address_t>   **  in_INSERT_NUM_REG_RE_PHY_NEW;//[nb_inst_insert]
77  sc_signal<Tcontrol_t        >   **  in_RETIRE_VAL               ;//[nb_inst_retire]
78  sc_signal<Tcontrol_t        >   ** out_RETIRE_ACK               ;//[nb_inst_retire]
79  sc_signal<Tcontrol_t        >   **  in_RETIRE_RESTORE           ;//[nb_inst_retire]
80//sc_signal<Tcontrol_t        >   **  in_RETIRE_READ_RA           ;//[nb_inst_retire]
81//sc_signal<Tgeneral_address_t>   **  in_RETIRE_NUM_REG_RA_PHY    ;//[nb_inst_retire]
82//sc_signal<Tcontrol_t        >   **  in_RETIRE_READ_RB           ;//[nb_inst_retire]
83//sc_signal<Tgeneral_address_t>   **  in_RETIRE_NUM_REG_RB_PHY    ;//[nb_inst_retire]
84//sc_signal<Tcontrol_t        >   **  in_RETIRE_READ_RC           ;//[nb_inst_retire]
85//sc_signal<Tspecial_address_t>   **  in_RETIRE_NUM_REG_RC_PHY    ;//[nb_inst_retire]
86  sc_signal<Tcontrol_t        >   **  in_RETIRE_WRITE_RD          ;//[nb_inst_retire]
87  sc_signal<Tcontrol_t        >   **  in_RETIRE_RESTORE_RD_PHY_OLD;//[nb_inst_retire]
88  sc_signal<Tgeneral_address_t>   **  in_RETIRE_NUM_REG_RD_PHY_OLD;//[nb_inst_retire]
89  sc_signal<Tgeneral_address_t>   **  in_RETIRE_NUM_REG_RD_PHY_NEW;//[nb_inst_retire]
90  sc_signal<Tcontrol_t        >   **  in_RETIRE_WRITE_RE          ;//[nb_inst_retire]
91  sc_signal<Tcontrol_t        >   **  in_RETIRE_RESTORE_RE_PHY_OLD;//[nb_inst_retire]
92  sc_signal<Tspecial_address_t>   **  in_RETIRE_NUM_REG_RE_PHY_OLD;//[nb_inst_retire]
93  sc_signal<Tspecial_address_t>   **  in_RETIRE_NUM_REG_RE_PHY_NEW;//[nb_inst_retire]
94  sc_signal<Tcontrol_t        >   ** out_PUSH_GPR_VAL             ;//[nb_reg_free]
95  sc_signal<Tcontrol_t        >   **  in_PUSH_GPR_ACK             ;//[nb_reg_free]
96  sc_signal<Tgeneral_address_t>   ** out_PUSH_GPR_NUM_REG         ;//[nb_reg_free]
97  sc_signal<Tcontrol_t        >   ** out_PUSH_SPR_VAL             ;//[nb_reg_free]
98  sc_signal<Tcontrol_t        >   **  in_PUSH_SPR_ACK             ;//[nb_reg_free]
99  sc_signal<Tspecial_address_t>   ** out_PUSH_SPR_NUM_REG         ;//[nb_reg_free]
100
101  ALLOC1_SC_SIGNAL( in_INSERT_VAL               ," in_INSERT_VAL               ",Tcontrol_t        ,_param->_nb_inst_insert);
102  ALLOC1_SC_SIGNAL(out_INSERT_ACK               ,"out_INSERT_ACK               ",Tcontrol_t        ,_param->_nb_inst_insert);
103//ALLOC1_SC_SIGNAL( in_INSERT_READ_RA           ," in_INSERT_READ_RA           ",Tcontrol_t        ,_param->_nb_inst_insert);
104//ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RA_PHY    ," in_INSERT_NUM_REG_RA_PHY    ",Tgeneral_address_t,_param->_nb_inst_insert);
105//ALLOC1_SC_SIGNAL( in_INSERT_READ_RB           ," in_INSERT_READ_RB           ",Tcontrol_t        ,_param->_nb_inst_insert);
106//ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RB_PHY    ," in_INSERT_NUM_REG_RB_PHY    ",Tgeneral_address_t,_param->_nb_inst_insert);
107//ALLOC1_SC_SIGNAL( in_INSERT_READ_RC           ," in_INSERT_READ_RC           ",Tcontrol_t        ,_param->_nb_inst_insert);
108//ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RC_PHY    ," in_INSERT_NUM_REG_RC_PHY    ",Tspecial_address_t,_param->_nb_inst_insert);
109  ALLOC1_SC_SIGNAL( in_INSERT_WRITE_RD          ," in_INSERT_WRITE_RD          ",Tcontrol_t        ,_param->_nb_inst_insert);
110  ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RD_PHY_OLD," in_INSERT_NUM_REG_RD_PHY_OLD",Tgeneral_address_t,_param->_nb_inst_insert);
111  ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RD_PHY_NEW," in_INSERT_NUM_REG_RD_PHY_NEW",Tgeneral_address_t,_param->_nb_inst_insert);
112  ALLOC1_SC_SIGNAL( in_INSERT_WRITE_RE          ," in_INSERT_WRITE_RE          ",Tcontrol_t        ,_param->_nb_inst_insert);
113  ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RE_PHY_OLD," in_INSERT_NUM_REG_RE_PHY_OLD",Tspecial_address_t,_param->_nb_inst_insert);
114  ALLOC1_SC_SIGNAL( in_INSERT_NUM_REG_RE_PHY_NEW," in_INSERT_NUM_REG_RE_PHY_NEW",Tspecial_address_t,_param->_nb_inst_insert);
115  ALLOC1_SC_SIGNAL( in_RETIRE_VAL               ," in_RETIRE_VAL               ",Tcontrol_t        ,_param->_nb_inst_retire);
116  ALLOC1_SC_SIGNAL(out_RETIRE_ACK               ,"out_RETIRE_ACK               ",Tcontrol_t        ,_param->_nb_inst_retire);
117  ALLOC1_SC_SIGNAL( in_RETIRE_RESTORE           ," in_RETIRE_RESTORE           ",Tcontrol_t        ,_param->_nb_inst_retire);
118//ALLOC1_SC_SIGNAL( in_RETIRE_READ_RA           ," in_RETIRE_READ_RA           ",Tcontrol_t        ,_param->_nb_inst_retire);
119//ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RA_PHY    ," in_RETIRE_NUM_REG_RA_PHY    ",Tgeneral_address_t,_param->_nb_inst_retire);
120//ALLOC1_SC_SIGNAL( in_RETIRE_READ_RB           ," in_RETIRE_READ_RB           ",Tcontrol_t        ,_param->_nb_inst_retire);
121//ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RB_PHY    ," in_RETIRE_NUM_REG_RB_PHY    ",Tgeneral_address_t,_param->_nb_inst_retire);
122//ALLOC1_SC_SIGNAL( in_RETIRE_READ_RC           ," in_RETIRE_READ_RC           ",Tcontrol_t        ,_param->_nb_inst_retire);
123//ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RC_PHY    ," in_RETIRE_NUM_REG_RC_PHY    ",Tspecial_address_t,_param->_nb_inst_retire);
124  ALLOC1_SC_SIGNAL( in_RETIRE_WRITE_RD          ," in_RETIRE_WRITE_RD          ",Tcontrol_t        ,_param->_nb_inst_retire);
125  ALLOC1_SC_SIGNAL( in_RETIRE_RESTORE_RD_PHY_OLD," in_RETIRE_RESTORE_RD_PHY_OLD",Tcontrol_t        ,_param->_nb_inst_retire);
126  ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RD_PHY_OLD," in_RETIRE_NUM_REG_RD_PHY_OLD",Tgeneral_address_t,_param->_nb_inst_retire);
127  ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RD_PHY_NEW," in_RETIRE_NUM_REG_RD_PHY_NEW",Tgeneral_address_t,_param->_nb_inst_retire);
128  ALLOC1_SC_SIGNAL( in_RETIRE_WRITE_RE          ," in_RETIRE_WRITE_RE          ",Tcontrol_t        ,_param->_nb_inst_retire);
129  ALLOC1_SC_SIGNAL( in_RETIRE_RESTORE_RE_PHY_OLD," in_RETIRE_RESTORE_RE_PHY_OLD",Tcontrol_t        ,_param->_nb_inst_retire);
130  ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RE_PHY_OLD," in_RETIRE_NUM_REG_RE_PHY_OLD",Tspecial_address_t,_param->_nb_inst_retire);
131  ALLOC1_SC_SIGNAL( in_RETIRE_NUM_REG_RE_PHY_NEW," in_RETIRE_NUM_REG_RE_PHY_NEW",Tspecial_address_t,_param->_nb_inst_retire);
132  ALLOC1_SC_SIGNAL(out_PUSH_GPR_VAL             ,"out_PUSH_GPR_VAL             ",Tcontrol_t        ,_param->_nb_reg_free);
133  ALLOC1_SC_SIGNAL( in_PUSH_GPR_ACK             ," in_PUSH_GPR_ACK             ",Tcontrol_t        ,_param->_nb_reg_free);
134  ALLOC1_SC_SIGNAL(out_PUSH_GPR_NUM_REG         ,"out_PUSH_GPR_NUM_REG         ",Tgeneral_address_t,_param->_nb_reg_free);
135  ALLOC1_SC_SIGNAL(out_PUSH_SPR_VAL             ,"out_PUSH_SPR_VAL             ",Tcontrol_t        ,_param->_nb_reg_free);
136  ALLOC1_SC_SIGNAL( in_PUSH_SPR_ACK             ," in_PUSH_SPR_ACK             ",Tcontrol_t        ,_param->_nb_reg_free);
137  ALLOC1_SC_SIGNAL(out_PUSH_SPR_NUM_REG         ,"out_PUSH_SPR_NUM_REG         ",Tspecial_address_t,_param->_nb_reg_free);
138
139 
140  /********************************************************
141   * Instanciation
142   ********************************************************/
143 
144  msg(_("<%s> : Instanciation of _Stat_List_unit.\n"),name.c_str());
145
146  (*(_Stat_List_unit->in_CLOCK))        (*(in_CLOCK));
147  (*(_Stat_List_unit->in_NRESET))       (*(in_NRESET));
148
149  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_VAL               ,_param->_nb_inst_insert);
150  INSTANCE1_SC_SIGNAL(_Stat_List_unit,out_INSERT_ACK               ,_param->_nb_inst_insert);
151//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_READ_RA           ,_param->_nb_inst_insert);
152//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RA_PHY    ,_param->_nb_inst_insert);
153//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_READ_RB           ,_param->_nb_inst_insert);
154//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RB_PHY    ,_param->_nb_inst_insert);
155//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_READ_RC           ,_param->_nb_inst_insert);
156//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RC_PHY    ,_param->_nb_inst_insert);
157  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_WRITE_RD          ,_param->_nb_inst_insert);
158  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RD_PHY_OLD,_param->_nb_inst_insert);
159  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RD_PHY_NEW,_param->_nb_inst_insert);
160  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_WRITE_RE          ,_param->_nb_inst_insert);
161  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RE_PHY_OLD,_param->_nb_inst_insert);
162  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_INSERT_NUM_REG_RE_PHY_NEW,_param->_nb_inst_insert);
163
164  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_VAL               ,_param->_nb_inst_retire);
165  INSTANCE1_SC_SIGNAL(_Stat_List_unit,out_RETIRE_ACK               ,_param->_nb_inst_retire);
166  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_RESTORE           ,_param->_nb_inst_retire);
167//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_READ_RA           ,_param->_nb_inst_retire);
168//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RA_PHY    ,_param->_nb_inst_retire);
169//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_READ_RB           ,_param->_nb_inst_retire);
170//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RB_PHY    ,_param->_nb_inst_retire);
171//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_READ_RC           ,_param->_nb_inst_retire);
172//INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RC_PHY    ,_param->_nb_inst_retire);
173  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_WRITE_RD          ,_param->_nb_inst_retire);
174  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_RESTORE_RD_PHY_OLD,_param->_nb_inst_retire);
175  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RD_PHY_OLD,_param->_nb_inst_retire);
176  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RD_PHY_NEW,_param->_nb_inst_retire);
177  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_WRITE_RE          ,_param->_nb_inst_retire);
178  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_RESTORE_RE_PHY_OLD,_param->_nb_inst_retire);
179  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RE_PHY_OLD,_param->_nb_inst_retire);
180  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_RETIRE_NUM_REG_RE_PHY_NEW,_param->_nb_inst_retire);
181
182  INSTANCE1_SC_SIGNAL(_Stat_List_unit,out_PUSH_GPR_VAL             ,_param->_nb_reg_free);
183  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_PUSH_GPR_ACK             ,_param->_nb_reg_free);
184  INSTANCE1_SC_SIGNAL(_Stat_List_unit,out_PUSH_GPR_NUM_REG         ,_param->_nb_reg_free);
185
186  INSTANCE1_SC_SIGNAL(_Stat_List_unit,out_PUSH_SPR_VAL             ,_param->_nb_reg_free);
187  INSTANCE1_SC_SIGNAL(_Stat_List_unit, in_PUSH_SPR_ACK             ,_param->_nb_reg_free);
188  INSTANCE1_SC_SIGNAL(_Stat_List_unit,out_PUSH_SPR_NUM_REG         ,_param->_nb_reg_free);
189
190  msg(_("<%s> : Start Simulation ............\n"),name.c_str());
191   
192  Time * _time = new Time();
193
194  /********************************************************
195   * Simulation - Begin
196   ********************************************************/
197
198  // Initialisation
199
200  const uint32_t seed = 0;
201//const uint32_t seed = static_cast<uint32_t>(time(NULL));
202
203  srand(seed);
204
205  int32_t percent_transaction_insert = 95;
206  int32_t percent_transaction_retire = 95;
207  int32_t percent_transaction_push   = 95;
208
209  uint32_t nb_thread = 0;
210  for (uint32_t i=0; i<_param->_nb_front_end; i++)
211    nb_thread += _param->_nb_context [i];
212
213  SC_START(0);
214  LABEL("Initialisation");
215
216  LABEL("Reset");
217  in_NRESET->write(0);
218  SC_START(5);
219  in_NRESET->write(1); 
220
221  LABEL("Loop of Test");
222
223  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
224    {
225      LABEL("Iteration %d",iteration);
226
227      entry_t gpr_status [_param->_nb_general_register];
228      entry_t spr_status [_param->_nb_special_register];
229
230      for (uint32_t i=0; i<_param->_nb_general_register; i++)
231        {
232          gpr_status[i]._is_free  = false;
233          gpr_status[i]._is_link  = (i<(nb_thread*31+1));
234          gpr_status[i]._is_valid = true;
235          gpr_status[i]._counter  = 0;
236        }
237      for (uint32_t i=0; i<_param->_nb_special_register; i++)
238        {
239          spr_status[i]._is_free  = false;
240          spr_status[i]._is_link  = (i<(nb_thread*2));
241          spr_status[i]._is_valid = true;
242          spr_status[i]._counter  = 0;
243        }
244
245      std::list<Tgeneral_address_t> free_list_gpr;
246      std::list<Tgeneral_address_t> free_list_spr;
247
248      // Test free register
249      while ((free_list_gpr.size() < (_param->_nb_general_register - (nb_thread*31+1))) and
250             (free_list_spr.size() < (_param->_nb_special_register - (nb_thread*2   ))))
251        {
252          for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
253            in_INSERT_VAL   [i]->write(0);
254          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
255            in_RETIRE_VAL   [i]->write(0);
256         
257          for (uint32_t i=0; i<_param->_nb_reg_free; i++)
258            {
259              in_PUSH_GPR_ACK [i]->write((rand()%100)<percent_transaction_push);
260              in_PUSH_SPR_ACK [i]->write((rand()%100)<percent_transaction_push);
261            }
262         
263          SC_START(0);
264
265          for (uint32_t i=0; i<_param->_nb_reg_free; i++)
266            {
267              if (out_PUSH_GPR_VAL [i]->read() and in_PUSH_GPR_ACK [i]->read())
268                {
269                  Tgeneral_address_t reg = out_PUSH_GPR_NUM_REG [i]->read();
270                 
271                  LABEL("PUSH_GPR [%d] - Accepted",i);
272                  LABEL(" * reg              : %d",reg);
273                  LABEL("   * status[%d]._is_free  : %d",reg,spr_status[reg]._is_free );
274                  LABEL("   * status[%d]._is_link  : %d",reg,spr_status[reg]._is_link );
275                  LABEL("   * status[%d]._is_valid : %d",reg,spr_status[reg]._is_valid);
276                  LABEL("   * status[%d]._counter  : %d",reg,spr_status[reg]._counter );
277
278                  TEST(bool, true,((gpr_status[reg]._is_free  == 0) and
279                                   (gpr_status[reg]._is_link  == 0) and
280                                   (gpr_status[reg]._is_valid == 1)//  and
281//                                 (gpr_status[reg]._counter  == 0)
282                                   ));
283
284                  gpr_status[reg]._is_free = 1;
285                  free_list_gpr.push_back(reg);
286                }
287
288              if (out_PUSH_SPR_VAL [i]->read() and in_PUSH_SPR_ACK [i]->read())
289                {
290                  Tspecial_address_t reg = out_PUSH_SPR_NUM_REG [i]->read();
291                 
292                  LABEL("PUSH_SPR [%d] - Accepted",i);
293                  LABEL(" * reg              : %d",reg);
294                  LABEL("   * status[%d]._is_free  : %d",reg,spr_status[reg]._is_free );
295                  LABEL("   * status[%d]._is_link  : %d",reg,spr_status[reg]._is_link );
296                  LABEL("   * status[%d]._is_valid : %d",reg,spr_status[reg]._is_valid);
297                  LABEL("   * status[%d]._counter  : %d",reg,spr_status[reg]._counter );
298
299                  TEST(bool, true,((spr_status[reg]._is_free  == 0) and
300                                   (spr_status[reg]._is_link  == 0) and
301                                   (spr_status[reg]._is_valid == 1)//  and
302//                                 (spr_status[reg]._counter  == 0)
303                                   ));
304
305                  spr_status[reg]._is_free = 1;
306                  free_list_spr.push_back(reg);
307                }
308            }
309         
310          SC_START(1);
311        }
312
313      LABEL("=======================");
314      LABEL("===== END OF INIT =====");
315      LABEL("=======================");
316
317      int32_t nb_cycle = 64;
318     
319      while (nb_cycle > 0)
320        {
321          std::list<Tgeneral_address_t>::iterator it_gpr = free_list_gpr.begin();
322          std::list<Tspecial_address_t>::iterator it_spr = free_list_spr.begin();
323
324
325          entry_t gpr_status_insert [_param->_nb_general_register];
326          entry_t spr_status_insert [_param->_nb_special_register];
327          entry_t gpr_status_retire [_param->_nb_general_register];
328          entry_t spr_status_retire [_param->_nb_special_register];
329
330          for (uint32_t i=0; i<_param->_nb_general_register; i++)
331            {
332              gpr_status_insert [i] = gpr_status[i];
333              gpr_status_retire [i] = gpr_status[i];
334            }
335          for (uint32_t i=0; i<_param->_nb_special_register; i++)
336            {
337              spr_status_insert [i] = spr_status[i];
338              spr_status_retire [i] = spr_status[i];
339            }
340
341          for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
342            {
343              Tgeneral_address_t ra       = (rand()%(_param->_nb_general_register-1))+1;
344              Tgeneral_address_t rb       = (rand()%(_param->_nb_general_register-1))+1;
345              Tspecial_address_t rc       = (rand()%(_param->_nb_special_register  ))  ;
346              Tgeneral_address_t rd       = (it_gpr != free_list_gpr.end())?*it_gpr:0;
347              Tspecial_address_t re       = (it_spr != free_list_spr.end())?*it_spr:0;
348
349              Tcontrol_t         read_ra  = (gpr_status_insert[ra]._is_link); // and (gpr_status_insert[ra]._counter < _param->_max_reader);
350              Tcontrol_t         read_rb  = (gpr_status_insert[rb]._is_link); // and (gpr_status_insert[rb]._counter < _param->_max_reader);
351              Tcontrol_t         read_rc  = (spr_status_insert[rc]._is_link); // and (spr_status_insert[rc]._counter < _param->_max_reader);
352              Tcontrol_t         write_rd = (it_gpr != free_list_gpr.end());
353              Tcontrol_t         write_re = (it_spr != free_list_spr.end());
354
355              in_INSERT_VAL                [i]->write((rand()%100) < percent_transaction_insert);
356//            in_INSERT_READ_RA            [i]->write(read_ra );
357//            in_INSERT_NUM_REG_RA_PHY     [i]->write(ra);
358//            in_INSERT_READ_RB            [i]->write(read_rb );
359//            in_INSERT_NUM_REG_RB_PHY     [i]->write(rb);
360//            in_INSERT_READ_RC            [i]->write(read_rc );
361//            in_INSERT_NUM_REG_RC_PHY     [i]->write(rc);
362              in_INSERT_WRITE_RD           [i]->write(write_rd);
363              in_INSERT_NUM_REG_RD_PHY_NEW [i]->write(rd);
364              in_INSERT_WRITE_RE           [i]->write(write_re);
365              in_INSERT_NUM_REG_RE_PHY_NEW [i]->write(re);
366
367              if (read_ra)
368                gpr_status_insert[ra]._counter++;
369              if (read_rb)
370                gpr_status_insert[rb]._counter++;
371              if (read_rc)
372                spr_status_insert[rc]._counter++;
373              if (write_rd)
374                it_gpr ++;
375              if (write_re)
376                it_spr ++;
377            }
378
379          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
380            {
381              Tgeneral_address_t ra       = (rand()%(_param->_nb_general_register-1))+1;
382              Tgeneral_address_t rb       = (rand()%(_param->_nb_general_register-1))+1;
383              Tspecial_address_t rc       = (rand()%(_param->_nb_special_register  ))  ;
384              Tgeneral_address_t rd_old   = (rand()%(_param->_nb_general_register-1))+1;
385              Tgeneral_address_t rd_new   = (rand()%(_param->_nb_general_register-1))+1;
386              Tspecial_address_t re_old   = (rand()%(_param->_nb_special_register  ))  ;
387              Tspecial_address_t re_new   = (rand()%(_param->_nb_special_register  ))  ;
388
389              Tcontrol_t         read_ra  = (gpr_status_retire[ra]._is_link); // and (gpr_status_retire[ra]._counter > 0);
390              Tcontrol_t         read_rb  = (gpr_status_retire[rb]._is_link); // and (gpr_status_retire[rb]._counter > 0);
391              Tcontrol_t         read_rc  = (spr_status_retire[rc]._is_link); // and (spr_status_retire[rc]._counter > 0);
392              Tcontrol_t         write_rd = (    (gpr_status_retire[rd_old]._is_link ) and
393                                                 (gpr_status_retire[rd_old]._is_valid) and
394                                                 (gpr_status_retire[rd_new]._is_link ) and
395                                             not (gpr_status_retire[rd_new]._is_valid));
396              Tcontrol_t         write_re = (    (spr_status_retire[re_old]._is_link ) and
397                                                 (spr_status_retire[re_old]._is_valid) and
398                                                 (spr_status_retire[re_new]._is_link ) and
399                                             not (spr_status_retire[re_new]._is_valid));
400
401              in_RETIRE_VAL                [i]->write((rand()%100) < percent_transaction_retire);
402//            in_RETIRE_READ_RA            [i]->write(read_ra );
403//            in_RETIRE_RESTORE            [i]->write(0);
404//            in_RETIRE_NUM_REG_RA_PHY     [i]->write(ra);
405//            in_RETIRE_READ_RB            [i]->write(read_rb );
406//            in_RETIRE_NUM_REG_RB_PHY     [i]->write(rb);
407//            in_RETIRE_READ_RC            [i]->write(read_rc );
408//            in_RETIRE_NUM_REG_RC_PHY     [i]->write(rc);
409              in_RETIRE_WRITE_RD           [i]->write(write_rd);
410              in_RETIRE_RESTORE_RD_PHY_OLD [i]->write(0);
411              in_RETIRE_NUM_REG_RD_PHY_OLD [i]->write(rd_old);
412              in_RETIRE_NUM_REG_RD_PHY_NEW [i]->write(rd_new);
413              in_RETIRE_WRITE_RE           [i]->write(write_re);
414              in_RETIRE_RESTORE_RE_PHY_OLD [i]->write(0);
415              in_RETIRE_NUM_REG_RE_PHY_OLD [i]->write(re_old);
416              in_RETIRE_NUM_REG_RE_PHY_NEW [i]->write(re_new);
417
418                if (read_ra)
419                  {
420                    gpr_status_retire[ra]._counter --;
421                  }
422                if (read_rb)
423                  {
424                    gpr_status_retire[rb]._counter --;
425                  }
426                if (read_rc)
427                  {
428                    spr_status_retire[rc]._counter --;
429                  }
430                if (write_rd)
431                  {
432                    gpr_status_retire[rd_old]._is_link  = 0;
433                    gpr_status_retire[rd_new]._is_valid = 1;
434                  }
435                if (write_re)
436                  {
437                    spr_status_retire[re_old]._is_link  = 0;
438                    spr_status_retire[re_new]._is_valid = 1;
439                  }
440
441            }
442
443
444          for (uint32_t i=0; i<_param->_nb_reg_free; i++)
445            {
446              in_PUSH_GPR_ACK [i]->write((rand()%100)<percent_transaction_push);
447              in_PUSH_SPR_ACK [i]->write((rand()%100)<percent_transaction_push);
448            }
449
450          SC_START(0);
451
452          it_gpr = free_list_gpr.begin();
453          it_spr = free_list_spr.begin();
454
455          for (uint32_t i=0; i<_param->_nb_inst_insert; i++)
456            {
457              Tcontrol_t         write_rd = in_INSERT_WRITE_RD           [i]->read();
458              Tcontrol_t         write_re = in_INSERT_WRITE_RE           [i]->read();
459
460              if (in_INSERT_VAL [i]->read() and out_INSERT_ACK [i]->read())
461                {
462//                Tcontrol_t         read_ra  = in_INSERT_READ_RA            [i]->read();
463//                Tgeneral_address_t ra       = in_INSERT_NUM_REG_RA_PHY     [i]->read();
464//                Tcontrol_t         read_rb  = in_INSERT_READ_RB            [i]->read();
465//                Tgeneral_address_t rb       = in_INSERT_NUM_REG_RB_PHY     [i]->read();
466//                Tcontrol_t         read_rc  = in_INSERT_READ_RC            [i]->read();
467//                Tspecial_address_t rc       = in_INSERT_NUM_REG_RC_PHY     [i]->read();
468                  Tgeneral_address_t rd_new   = in_INSERT_NUM_REG_RD_PHY_NEW [i]->read();
469                  Tspecial_address_t re_new   = in_INSERT_NUM_REG_RE_PHY_NEW [i]->read();               
470                 
471                  LABEL("INSERT [%d] - Accepted",i);
472//                LABEL(" * read_ra          : %d",read_ra );
473//                LABEL(" * reg_ra           : %d",ra      );
474//                LABEL("   * status[%d]._is_free  : %d",ra,spr_status[ra]._is_free );
475//                LABEL("   * status[%d]._is_link  : %d",ra,spr_status[ra]._is_link );
476//                LABEL("   * status[%d]._is_valid : %d",ra,spr_status[ra]._is_valid);
477//                LABEL("   * status[%d]._counter  : %d",ra,spr_status[ra]._counter );
478//                LABEL(" * read_rb          : %d",read_rb );
479//                LABEL(" * reg_rb           : %d",rb      );
480//                LABEL("   * status[%d]._is_free  : %d",rb,spr_status[rb]._is_free );
481//                LABEL("   * status[%d]._is_link  : %d",rb,spr_status[rb]._is_link );
482//                LABEL("   * status[%d]._is_valid : %d",rb,spr_status[rb]._is_valid);
483//                LABEL("   * status[%d]._counter  : %d",rb,spr_status[rb]._counter );
484//                LABEL(" * read_rc          : %d",read_rc );
485//                LABEL(" * reg_rc           : %d",rc      );
486//                LABEL("   * status[%d]._is_free  : %d",rc,spr_status[rc]._is_free );
487//                LABEL("   * status[%d]._is_link  : %d",rc,spr_status[rc]._is_link );
488//                LABEL("   * status[%d]._is_valid : %d",rc,spr_status[rc]._is_valid);
489//                LABEL("   * status[%d]._counter  : %d",rc,spr_status[rc]._counter );
490                  LABEL(" * read_rd          : %d",write_rd);
491                  LABEL(" * reg_rd_new       : %d",rd_new  );
492                  LABEL("   * status[%d]._is_free  : %d",rd_new,spr_status[rd_new]._is_free );
493                  LABEL("   * status[%d]._is_link  : %d",rd_new,spr_status[rd_new]._is_link );
494                  LABEL("   * status[%d]._is_valid : %d",rd_new,spr_status[rd_new]._is_valid);
495                  LABEL("   * status[%d]._counter  : %d",rd_new,spr_status[rd_new]._counter );
496                  LABEL(" * read_re          : %d",write_re);
497                  LABEL(" * reg_re_new       : %d",re_new  );
498                  LABEL("   * status[%d]._is_free  : %d",re_new,spr_status[re_new]._is_free );
499                  LABEL("   * status[%d]._is_link  : %d",re_new,spr_status[re_new]._is_link );
500                  LABEL("   * status[%d]._is_valid : %d",re_new,spr_status[re_new]._is_valid);
501                  LABEL("   * status[%d]._counter  : %d",re_new,spr_status[re_new]._counter );
502                 
503//                if (read_ra)
504//                  {
505//                    gpr_status[ra]._counter ++;
506//                  }
507//                if (read_rb)
508//                  {
509//                    gpr_status[rb]._counter ++;
510//                  }
511//                if (read_rc)
512//                  {
513//                    spr_status[rc]._counter ++;
514//                  }
515                  if (write_rd)
516                    {
517                      Tgeneral_address_t reg = *it_gpr;
518                      TEST(Tgeneral_address_t,reg,rd_new);
519                     
520                      it_gpr = free_list_gpr.erase(it_gpr);
521                     
522                      gpr_status[reg]._is_free  = 0;
523                      gpr_status[reg]._is_link  = 1;
524                      gpr_status[reg]._is_valid = 0;
525                    }
526                 
527                  if (write_re)
528                    {
529                      Tspecial_address_t reg = *it_spr;
530                      TEST(Tspecial_address_t,reg,re_new);
531                     
532                      it_spr = free_list_spr.erase(it_spr);
533                     
534                      spr_status[reg]._is_free  = 0;
535                      spr_status[reg]._is_link  = 1;
536                      spr_status[reg]._is_valid = 0;
537                    }
538                }
539              else
540                {
541                  if (write_rd)
542                    it_gpr ++;
543                  if (write_re)
544                    it_spr ++;
545                }
546            }
547         
548          for (uint32_t i=0; i<_param->_nb_inst_retire; i++)
549            if (in_RETIRE_VAL [i]->read() and out_RETIRE_ACK [i]->read())
550              {
551                Tcontrol_t         restore        = in_RETIRE_RESTORE            [i]->read();
552//              Tcontrol_t         read_ra        = in_RETIRE_READ_RA            [i]->read();
553//              Tgeneral_address_t ra             = in_RETIRE_NUM_REG_RA_PHY     [i]->read();
554//              Tcontrol_t         read_rb        = in_RETIRE_READ_RB            [i]->read();
555//              Tgeneral_address_t rb             = in_RETIRE_NUM_REG_RB_PHY     [i]->read();
556//              Tcontrol_t         read_rc        = in_RETIRE_READ_RC            [i]->read();
557//              Tspecial_address_t rc             = in_RETIRE_NUM_REG_RC_PHY     [i]->read();
558                Tcontrol_t         write_rd       = in_RETIRE_WRITE_RD           [i]->read();
559                Tcontrol_t         restore_rd_old = in_RETIRE_RESTORE_RD_PHY_OLD [i]->read();
560                Tgeneral_address_t rd_old         = in_RETIRE_NUM_REG_RD_PHY_OLD [i]->read();
561                Tgeneral_address_t rd_new         = in_RETIRE_NUM_REG_RD_PHY_NEW [i]->read();
562                Tcontrol_t         write_re       = in_RETIRE_WRITE_RE           [i]->read();
563                Tcontrol_t         restore_re_old = in_RETIRE_RESTORE_RE_PHY_OLD [i]->read();
564                Tgeneral_address_t re_old         = in_RETIRE_NUM_REG_RE_PHY_OLD [i]->read();
565                Tgeneral_address_t re_new         = in_RETIRE_NUM_REG_RE_PHY_NEW [i]->read();           
566
567                LABEL("RETIRE [%d] - Accepted",i);
568                LABEL(" * restore          : %d",restore);
569//              LABEL(" * read_ra          : %d",read_ra );
570//              LABEL(" * reg_ra           : %d",ra      );
571//              LABEL("   * status[%d]._is_free  : %d",ra,spr_status[ra]._is_free );
572//              LABEL("   * status[%d]._is_link  : %d",ra,spr_status[ra]._is_link );
573//              LABEL("   * status[%d]._is_valid : %d",ra,spr_status[ra]._is_valid);
574//              LABEL("   * status[%d]._counter  : %d",ra,spr_status[ra]._counter );
575//              LABEL(" * read_rb          : %d",read_rb );
576//              LABEL(" * reg_rb           : %d",rb      );
577//              LABEL("   * status[%d]._is_free  : %d",rb,spr_status[rb]._is_free );
578//              LABEL("   * status[%d]._is_link  : %d",rb,spr_status[rb]._is_link );
579//              LABEL("   * status[%d]._is_valid : %d",rb,spr_status[rb]._is_valid);
580//              LABEL("   * status[%d]._counter  : %d",rb,spr_status[rb]._counter );
581//              LABEL(" * read_rc          : %d",read_rc );
582//              LABEL(" * reg_rc           : %d",rc      );
583//              LABEL("   * status[%d]._is_free  : %d",rc,spr_status[rc]._is_free );
584//              LABEL("   * status[%d]._is_link  : %d",rc,spr_status[rc]._is_link );
585//              LABEL("   * status[%d]._is_valid : %d",rc,spr_status[rc]._is_valid);
586//              LABEL("   * status[%d]._counter  : %d",rc,spr_status[rc]._counter );
587                LABEL(" * read_rd          : %d",write_rd);
588                LABEL(" * restore_rd_old   : %d",restore_rd_old);
589                LABEL(" * reg_rd_old       : %d",rd_old  );
590                LABEL("   * status[%d]._is_free  : %d",rd_old,spr_status[rd_old]._is_free );
591                LABEL("   * status[%d]._is_link  : %d",rd_old,spr_status[rd_old]._is_link );
592                LABEL("   * status[%d]._is_valid : %d",rd_old,spr_status[rd_old]._is_valid);
593                LABEL("   * status[%d]._counter  : %d",rd_old,spr_status[rd_old]._counter );
594                LABEL(" * reg_rd_new       : %d",rd_new  );
595                LABEL("   * status[%d]._is_free  : %d",rd_new,spr_status[rd_new]._is_free );
596                LABEL("   * status[%d]._is_link  : %d",rd_new,spr_status[rd_new]._is_link );
597                LABEL("   * status[%d]._is_valid : %d",rd_new,spr_status[rd_new]._is_valid);
598                LABEL("   * status[%d]._counter  : %d",rd_new,spr_status[rd_new]._counter );
599                LABEL(" * read_re          : %d",write_re);
600                LABEL(" * restore_re_old   : %d",restore_re_old);
601                LABEL(" * reg_re_old       : %d",re_old  );
602                LABEL("   * status[%d]._is_free  : %d",re_old,spr_status[re_old]._is_free );
603                LABEL("   * status[%d]._is_link  : %d",re_old,spr_status[re_old]._is_link );
604                LABEL("   * status[%d]._is_valid : %d",re_old,spr_status[re_old]._is_valid);
605                LABEL("   * status[%d]._counter  : %d",re_old,spr_status[re_old]._counter );
606                LABEL(" * reg_re_new       : %d",re_new  );
607                LABEL("   * status[%d]._is_free  : %d",re_new,spr_status[re_new]._is_free );
608                LABEL("   * status[%d]._is_link  : %d",re_new,spr_status[re_new]._is_link );
609                LABEL("   * status[%d]._is_valid : %d",re_new,spr_status[re_new]._is_valid);
610                LABEL("   * status[%d]._counter  : %d",re_new,spr_status[re_new]._counter );
611
612//              if (read_ra)
613//                {
614//                  gpr_status[ra]._counter --;
615//                }
616//              if (read_rb)
617//                {
618//                  gpr_status[rb]._counter --;
619//                }
620//              if (read_rc)
621//                {
622//                  spr_status[rc]._counter --;
623//                }
624                if (write_rd)
625                  {
626                    if (restore)
627                      {
628                        if (restore_rd_old)
629                          {
630                            gpr_status[rd_old]._is_link  = 1;
631                            gpr_status[rd_new]._is_link  = 0;
632                            gpr_status[rd_new]._is_valid = 1;
633                          }
634                        else
635                          {
636                            gpr_status[rd_old]._is_link  = 0;
637                            gpr_status[rd_new]._is_link  = 0;
638                            gpr_status[rd_new]._is_valid = 1;
639                          }
640                      }
641                    else
642                      {
643                        gpr_status[rd_old]._is_link  = 0;
644                        gpr_status[rd_new]._is_valid = 1;
645                      }
646
647                  }
648                if (write_re)
649                  {
650                    if (restore_re_old)
651                      {
652                        spr_status[re_old]._is_link  = 1;
653                        spr_status[re_new]._is_link  = 0;
654                        spr_status[re_new]._is_valid = 1;
655                      }
656                    else
657                      {
658                        spr_status[re_old]._is_link  = 0;
659                        spr_status[re_new]._is_valid = 1;
660                      }
661                  }
662              }
663
664
665          for (uint32_t i=0; i<_param->_nb_reg_free; i++)
666            {
667              if (out_PUSH_GPR_VAL [i]->read() and in_PUSH_GPR_ACK [i]->read())
668                {
669                  Tgeneral_address_t reg = out_PUSH_GPR_NUM_REG [i]->read();
670       
671                  LABEL("PUSH_GPR [%d] - Accepted",i);
672                  LABEL(" * reg              : %d",reg);
673                  LABEL("   * status[%d]._is_free  : %d",reg,spr_status[reg]._is_free );
674                  LABEL("   * status[%d]._is_link  : %d",reg,spr_status[reg]._is_link );
675                  LABEL("   * status[%d]._is_valid : %d",reg,spr_status[reg]._is_valid);
676                  LABEL("   * status[%d]._counter  : %d",reg,spr_status[reg]._counter );
677
678                  TEST(bool, true,((gpr_status[reg]._is_free  == 0) and
679                                   (gpr_status[reg]._is_link  == 0) and
680                                   (gpr_status[reg]._is_valid == 1)//  and
681//                                 (gpr_status[reg]._counter  == 0)
682                                   ));
683
684                  gpr_status[reg]._is_free = 1;
685                  free_list_gpr.push_back(reg);
686                }
687
688              if (out_PUSH_SPR_VAL [i]->read() and in_PUSH_SPR_ACK [i]->read())
689                {
690                  Tspecial_address_t reg = out_PUSH_SPR_NUM_REG [i]->read();
691
692                  LABEL("PUSH_SPR [%d] - Accepted",i);
693                  LABEL(" * reg              : %d",reg);
694                  LABEL("   * status[%d]._is_free  : %d",reg,spr_status[reg]._is_free );
695                  LABEL("   * status[%d]._is_link  : %d",reg,spr_status[reg]._is_link );
696                  LABEL("   * status[%d]._is_valid : %d",reg,spr_status[reg]._is_valid);
697                  LABEL("   * status[%d]._counter  : %d",reg,spr_status[reg]._counter );
698
699                  TEST(bool, true,((spr_status[reg]._is_free  == 0) and
700                                   (spr_status[reg]._is_link  == 0) and
701                                   (spr_status[reg]._is_valid == 1)//  and
702//                                 (spr_status[reg]._counter  == 0)
703                                   ));
704
705                  spr_status[reg]._is_free = 1;
706                  free_list_spr.push_back(reg);
707                }
708            }
709         
710          SC_START(1);
711          nb_cycle --;
712        }
713    }
714
715  /********************************************************
716   * Simulation - End
717   ********************************************************/
718
719  TEST_OK ("End of Simulation");
720  delete _time;
721
722  msg(_("<%s> : ............ Stop Simulation\n"),name.c_str());
723
724  delete in_CLOCK;
725  delete in_NRESET;
726
727  delete []  in_INSERT_VAL               ;
728  delete [] out_INSERT_ACK               ;
729//delete []  in_INSERT_READ_RA           ;
730//delete []  in_INSERT_NUM_REG_RA_PHY    ;
731//delete []  in_INSERT_READ_RB           ;
732//delete []  in_INSERT_NUM_REG_RB_PHY    ;
733//delete []  in_INSERT_READ_RC           ;
734//delete []  in_INSERT_NUM_REG_RC_PHY    ;
735  delete []  in_INSERT_WRITE_RD          ;
736  delete []  in_INSERT_NUM_REG_RD_PHY_OLD;
737  delete []  in_INSERT_NUM_REG_RD_PHY_NEW;
738  delete []  in_INSERT_WRITE_RE          ;
739  delete []  in_INSERT_NUM_REG_RE_PHY_OLD;
740  delete []  in_INSERT_NUM_REG_RE_PHY_NEW;
741  delete []  in_RETIRE_VAL               ;
742  delete [] out_RETIRE_ACK               ;
743  delete []  in_RETIRE_RESTORE           ;
744//delete []  in_RETIRE_READ_RA           ;
745//delete []  in_RETIRE_NUM_REG_RA_PHY    ;
746//delete []  in_RETIRE_READ_RB           ;
747//delete []  in_RETIRE_NUM_REG_RB_PHY    ;
748//delete []  in_RETIRE_READ_RC           ;
749//delete []  in_RETIRE_NUM_REG_RC_PHY    ;
750  delete []  in_RETIRE_WRITE_RD          ;
751  delete []  in_RETIRE_RESTORE_RD_PHY_OLD;
752  delete []  in_RETIRE_NUM_REG_RD_PHY_OLD;
753  delete []  in_RETIRE_NUM_REG_RD_PHY_NEW;
754  delete []  in_RETIRE_WRITE_RE          ;
755  delete []  in_RETIRE_RESTORE_RE_PHY_OLD;
756  delete []  in_RETIRE_NUM_REG_RE_PHY_OLD;
757  delete []  in_RETIRE_NUM_REG_RE_PHY_NEW;
758  delete [] out_PUSH_GPR_VAL             ;
759  delete []  in_PUSH_GPR_ACK             ;
760  delete [] out_PUSH_GPR_NUM_REG         ;
761  delete [] out_PUSH_SPR_VAL             ;
762  delete []  in_PUSH_SPR_ACK             ;
763  delete [] out_PUSH_SPR_NUM_REG         ;
764
765#endif
766
767  delete _Stat_List_unit;
768#ifdef STATISTICS
769  delete _parameters_statistics;
770#endif
771}
Note: See TracBrowser for help on using the repository browser.