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

Last change on this file since 81 was 81, checked in by rosiere, 16 years ago
  • Finish Environment (and test)
  • Continue predictor_unit
  • Add external tools
  • svn keyword "Id" set
  • Property svn:keywords set to Id
File size: 36.8 KB
Line 
1/*
2 * $Id: test.cpp 81 2008-04-15 18:40:01Z rosiere $
3 *
4 * [ Description ]
5 *
6 * Test
7 */
8
9#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/include/test.h"
10#include "Common/include/Test.h"
11
12#define NB_ITERATION  1
13//64
14#define CYCLE_MAX     (1024*NB_ITERATION)
15
16#define LABEL(str)                                                                       \
17{                                                                                        \
18  cout << "{"+toString(static_cast<uint32_t>(sc_simulation_time()))+"} " << str << endl; \
19} while(0)
20
21static uint32_t cycle = 0;
22
23#define SC_START(cycle_offset)                                          \
24do                                                                      \
25{                                                                       \
26/*cout << "SC_START (begin)" << endl;*/                                 \
27                                                                        \
28  uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time()); \
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  sc_start(cycle_offset);                                               \
40/*cout << "SC_START (end  )" << endl;*/                                 \
41} while(0)
42
43void test (string name,
44           morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue::Parameters * _param)
45{
46  cout << "<" << name << "> : Simulation SystemC" << endl;
47
48#ifdef STATISTICS
49  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
50#endif
51
52  Read_queue * _Read_queue = new Read_queue (name.c_str(),
53#ifdef STATISTICS
54                                             _parameters_statistics,
55#endif
56                                             _param);
57 
58#ifdef SYSTEMC
59  /*********************************************************************
60   * Déclarations des signaux
61   *********************************************************************/
62  string rename;
63
64  sc_clock                               * CLOCK = new sc_clock ("clock", 1.0, 0.5);
65  sc_signal<Tcontrol_t>                  * NRESET= new sc_signal<Tcontrol_t> ("NRESET");
66
67    // ~~~~~[ Interface "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
68
69  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_VAL          = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_VAL         ");
70  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_ACK          = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_ACK         ");
71  sc_signal<Tcontext_t         >         * READ_QUEUE_IN_CONTEXT_ID   = new sc_signal<Tcontext_t         >         ("READ_QUEUE_IN_CONTEXT_ID  ");
72  sc_signal<Tcontext_t         >         * READ_QUEUE_IN_FRONT_END_ID = new sc_signal<Tcontext_t         >         ("READ_QUEUE_IN_FRONT_END_ID ");
73  sc_signal<Tcontext_t         >         * READ_QUEUE_IN_OOO_ENGINE_ID= new sc_signal<Tcontext_t         >         ("READ_QUEUE_IN_OOO_ENGINE_ID");
74  sc_signal<Tpacket_t          >         * READ_QUEUE_IN_ROB_ID       = new sc_signal<Tpacket_t          >         ("READ_QUEUE_IN_ROB_ID   ");
75  sc_signal<Toperation_t       >         * READ_QUEUE_IN_OPERATION    = new sc_signal<Toperation_t       >         ("READ_QUEUE_IN_OPERATION   ");
76  sc_signal<Ttype_t            >         * READ_QUEUE_IN_TYPE         = new sc_signal<Ttype_t            >         ("READ_QUEUE_IN_TYPE        ");
77  sc_signal<Tlsq_ptr_t         >         * READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE = new sc_signal<Tlsq_ptr_t>         ("READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE");
78  sc_signal<Tlsq_ptr_t         >         * READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE  = new sc_signal<Tlsq_ptr_t>         ("READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ");
79  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_HAS_IMMEDIAT = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_HAS_IMMEDIAT");
80  sc_signal<Tgeneral_data_t    >         * READ_QUEUE_IN_IMMEDIAT     = new sc_signal<Tgeneral_data_t    >         ("READ_QUEUE_IN_IMMEDIAT    ");
81  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_READ_RA      = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_READ_RA     ");
82  sc_signal<Tgeneral_address_t >         * READ_QUEUE_IN_NUM_REG_RA   = new sc_signal<Tgeneral_address_t >         ("READ_QUEUE_IN_NUM_REG_RA  ");
83  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_READ_RB      = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_READ_RB     ");
84  sc_signal<Tgeneral_address_t >         * READ_QUEUE_IN_NUM_REG_RB   = new sc_signal<Tgeneral_address_t >         ("READ_QUEUE_IN_NUM_REG_RB  ");
85  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_READ_RC      = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_READ_RC     ");
86  sc_signal<Tspecial_address_t >         * READ_QUEUE_IN_NUM_REG_RC   = new sc_signal<Tspecial_address_t >         ("READ_QUEUE_IN_NUM_REG_RC  ");
87  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_WRITE_RD     = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_WRITE_RD    ");
88  sc_signal<Tgeneral_address_t >         * READ_QUEUE_IN_NUM_REG_RD   = new sc_signal<Tgeneral_address_t >         ("READ_QUEUE_IN_NUM_REG_RD  ");
89  sc_signal<Tcontrol_t         >         * READ_QUEUE_IN_WRITE_RE     = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_IN_WRITE_RE    ");
90  sc_signal<Tspecial_address_t >         * READ_QUEUE_IN_NUM_REG_RE   = new sc_signal<Tspecial_address_t >         ("READ_QUEUE_IN_NUM_REG_RE  ");
91
92    // ~~~~~[ Interface "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
93
94  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_VAL         = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_VAL         ");
95  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_ACK         = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_ACK         ");
96  sc_signal<Tcontext_t         >         * READ_QUEUE_OUT_CONTEXT_ID    = new sc_signal<Tcontext_t         >         ("READ_QUEUE_OUT_CONTEXT_ID   ");
97  sc_signal<Tcontext_t         >         * READ_QUEUE_OUT_FRONT_END_ID  = new sc_signal<Tcontext_t         >         ("READ_QUEUE_OUT_FRONT_END_ID ");
98  sc_signal<Tcontext_t         >         * READ_QUEUE_OUT_OOO_ENGINE_ID = new sc_signal<Tcontext_t         >         ("READ_QUEUE_OUT_OOO_ENGINE_ID");
99  sc_signal<Tpacket_t          >         * READ_QUEUE_OUT_ROB_ID      = new sc_signal<Tpacket_t          >         ("READ_QUEUE_OUT_ROB_ID   ");
100  sc_signal<Toperation_t       >         * READ_QUEUE_OUT_OPERATION   = new sc_signal<Toperation_t       >         ("READ_QUEUE_OUT_OPERATION   ");
101  sc_signal<Ttype_t            >         * READ_QUEUE_OUT_TYPE        = new sc_signal<Ttype_t            >         ("READ_QUEUE_OUT_TYPE        ");
102  sc_signal<Tlsq_ptr_t         >         * READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE = new sc_signal<Tlsq_ptr_t>        ("READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE");
103  sc_signal<Tlsq_ptr_t         >         * READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE  = new sc_signal<Tlsq_ptr_t>        ("READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ");
104  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_HAS_IMMEDIAT= new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_HAS_IMMEDIAT");
105  sc_signal<Tgeneral_data_t    >         * READ_QUEUE_OUT_IMMEDIAT    = new sc_signal<Tgeneral_data_t    >         ("READ_QUEUE_OUT_IMMEDIAT    ");
106  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_READ_RA     = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_READ_RA     ");
107  sc_signal<Tgeneral_address_t >         * READ_QUEUE_OUT_NUM_REG_RA  = new sc_signal<Tgeneral_address_t >         ("READ_QUEUE_OUT_NUM_REG_RA  ");
108  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_DATA_RA_VAL = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_DATA_RA_VAL ");
109  sc_signal<Tgeneral_data_t    >         * READ_QUEUE_OUT_DATA_RA     = new sc_signal<Tgeneral_data_t    >         ("READ_QUEUE_OUT_DATA_RA     ");
110  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_READ_RB     = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_READ_RB     ");
111  sc_signal<Tgeneral_address_t >         * READ_QUEUE_OUT_NUM_REG_RB  = new sc_signal<Tgeneral_address_t >         ("READ_QUEUE_OUT_NUM_REG_RB  ");
112  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_DATA_RB_VAL = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_DATA_RB_VAL ");
113  sc_signal<Tgeneral_data_t    >         * READ_QUEUE_OUT_DATA_RB     = new sc_signal<Tgeneral_data_t    >         ("READ_QUEUE_OUT_DATA_RB     ");
114  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_READ_RC     = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_READ_RC     ");
115  sc_signal<Tspecial_address_t >         * READ_QUEUE_OUT_NUM_REG_RC  = new sc_signal<Tspecial_address_t >         ("READ_QUEUE_OUT_NUM_REG_RC  ");
116  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_DATA_RC_VAL = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_DATA_RC_VAL ");
117  sc_signal<Tspecial_data_t    >         * READ_QUEUE_OUT_DATA_RC     = new sc_signal<Tspecial_data_t    >         ("READ_QUEUE_OUT_DATA_RC     ");
118  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_WRITE_RD    = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_WRITE_RD    ");
119  sc_signal<Tgeneral_address_t >         * READ_QUEUE_OUT_NUM_REG_RD  = new sc_signal<Tgeneral_address_t >         ("READ_QUEUE_OUT_NUM_REG_RD  ");
120  sc_signal<Tcontrol_t         >         * READ_QUEUE_OUT_WRITE_RE    = new sc_signal<Tcontrol_t         >         ("READ_QUEUE_OUT_WRITE_RE    ");
121  sc_signal<Tspecial_address_t >         * READ_QUEUE_OUT_NUM_REG_RE  = new sc_signal<Tspecial_address_t >         ("READ_QUEUE_OUT_NUM_REG_RE  ");
122
123    // ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
124
125  sc_signal<Tcontrol_t         > ** GPR_READ_VAL        = new sc_signal<Tcontrol_t         > * [_param->_nb_gpr_read];
126  sc_signal<Tcontrol_t         > ** GPR_READ_ACK        = new sc_signal<Tcontrol_t         > * [_param->_nb_gpr_read];
127  sc_signal<Tcontext_t         > ** GPR_READ_OOO_ENGINE_ID = new sc_signal<Tcontext_t         > * [_param->_nb_gpr_read];
128  sc_signal<Tgeneral_address_t > ** GPR_READ_NUM_REG    = new sc_signal<Tgeneral_address_t > * [_param->_nb_gpr_read];
129  sc_signal<Tgeneral_data_t    > ** GPR_READ_DATA       = new sc_signal<Tgeneral_data_t    > * [_param->_nb_gpr_read];
130  sc_signal<Tcontrol_t         > ** GPR_READ_DATA_VAL   = new sc_signal<Tcontrol_t         > * [_param->_nb_gpr_read];
131
132  for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
133    {
134      rename = "GPR_READ_"+toString(i)+"_VAL";   
135      GPR_READ_VAL        [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
136      rename = "GPR_READ_"+toString(i)+"_ACK";     
137      GPR_READ_ACK        [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
138      rename = "GPR_READ_"+toString(i)+"_OOO_ENGINE_ID";
139      GPR_READ_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t         > (rename.c_str());
140      rename = "GPR_READ_"+toString(i)+"_NUM_REG"; 
141      GPR_READ_NUM_REG    [i] = new sc_signal<Tgeneral_address_t > (rename.c_str());
142      rename = "GPR_READ_"+toString(i)+"_DATA";   
143      GPR_READ_DATA       [i] = new sc_signal<Tgeneral_data_t    > (rename.c_str());
144      rename = "GPR_READ_"+toString(i)+"_DATA_VAL";
145      GPR_READ_DATA_VAL   [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
146    }
147
148    // ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
149
150  sc_signal<Tcontrol_t         > ** SPR_READ_VAL        = new sc_signal<Tcontrol_t         > * [_param->_nb_spr_read];
151  sc_signal<Tcontrol_t         > ** SPR_READ_ACK        = new sc_signal<Tcontrol_t         > * [_param->_nb_spr_read];
152  sc_signal<Tcontext_t         > ** SPR_READ_OOO_ENGINE_ID = new sc_signal<Tcontext_t         > * [_param->_nb_spr_read];
153  sc_signal<Tspecial_address_t > ** SPR_READ_NUM_REG    = new sc_signal<Tspecial_address_t > * [_param->_nb_spr_read];
154  sc_signal<Tspecial_data_t    > ** SPR_READ_DATA       = new sc_signal<Tspecial_data_t    > * [_param->_nb_spr_read];
155  sc_signal<Tcontrol_t         > ** SPR_READ_DATA_VAL   = new sc_signal<Tcontrol_t         > * [_param->_nb_spr_read];
156
157  for (uint32_t i=0; i<_param->_nb_spr_read; i++)
158    {
159      rename = "SPR_READ_"+toString(i)+"_VAL";   
160      SPR_READ_VAL         [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
161      rename = "SPR_READ_"+toString(i)+"_ACK";     
162      SPR_READ_ACK         [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
163      rename = "SPR_READ_"+toString(i)+"_OOO_ENGINE_ID"; 
164      SPR_READ_OOO_ENGINE_ID  [i] = new sc_signal<Tcontext_t         > (rename.c_str());
165      rename = "SPR_READ_"+toString(i)+"_NUM_REG"; 
166      SPR_READ_NUM_REG     [i] = new sc_signal<Tspecial_address_t > (rename.c_str());
167      rename = "SPR_READ_"+toString(i)+"_DATA";   
168      SPR_READ_DATA        [i] = new sc_signal<Tspecial_data_t    > (rename.c_str());
169      rename = "SPR_READ_"+toString(i)+"_DATA_VAL";
170      SPR_READ_DATA_VAL    [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
171    }
172
173    // ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
174
175  sc_signal<Tcontrol_t         > ** GPR_WRITE_VAL        = new sc_signal<Tcontrol_t         > * [_param->_nb_gpr_write];
176  sc_signal<Tcontext_t         > ** GPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t         > * [_param->_nb_gpr_write];
177  sc_signal<Tgeneral_address_t > ** GPR_WRITE_NUM_REG    = new sc_signal<Tgeneral_address_t > * [_param->_nb_gpr_write];
178  sc_signal<Tgeneral_data_t    > ** GPR_WRITE_DATA       = new sc_signal<Tgeneral_data_t    > * [_param->_nb_gpr_write];
179
180  for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
181    {
182      rename = "GPR_WRITE_"+toString(i)+"_VAL"       ;
183      GPR_WRITE_VAL        [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
184      rename = "GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID";
185      GPR_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t         > (rename.c_str());
186      rename = "GPR_WRITE_"+toString(i)+"_NUM_REG"   ;
187      GPR_WRITE_NUM_REG    [i] = new sc_signal<Tgeneral_address_t > (rename.c_str());
188      rename = "GPR_WRITE_"+toString(i)+"_DATA"      ;
189      GPR_WRITE_DATA       [i] = new sc_signal<Tgeneral_data_t    > (rename.c_str());
190    }
191
192    // ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
193
194  sc_signal<Tcontrol_t         > ** SPR_WRITE_VAL        = new sc_signal<Tcontrol_t         > * [_param->_nb_spr_write];
195  sc_signal<Tcontext_t         > ** SPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t         > * [_param->_nb_spr_write];
196  sc_signal<Tspecial_address_t > ** SPR_WRITE_NUM_REG    = new sc_signal<Tspecial_address_t > * [_param->_nb_spr_write];
197  sc_signal<Tspecial_data_t    > ** SPR_WRITE_DATA       = new sc_signal<Tspecial_data_t    > * [_param->_nb_spr_write];
198
199  for (uint32_t i=0; i<_param->_nb_spr_write; i++)
200    {
201      rename = "SPR_WRITE_"+toString(i)+"_VAL"       ;
202      SPR_WRITE_VAL        [i] = new sc_signal<Tcontrol_t         > (rename.c_str());
203      rename = "SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID";
204      SPR_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t         > (rename.c_str());
205      rename = "SPR_WRITE_"+toString(i)+"_NUM_REG"   ;
206      SPR_WRITE_NUM_REG    [i] = new sc_signal<Tspecial_address_t > (rename.c_str());
207      rename = "SPR_WRITE_"+toString(i)+"_DATA"      ;
208      SPR_WRITE_DATA       [i] = new sc_signal<Tspecial_data_t    > (rename.c_str());
209    }
210
211  /********************************************************
212   * Instanciation
213   ********************************************************/
214 
215  cout << "<" << name << "> Instanciation of _Read_queue" << endl;
216 
217  (*(_Read_queue->in_CLOCK ))        (*(CLOCK));
218  (*(_Read_queue->in_NRESET))        (*(NRESET));
219
220  (*(_Read_queue-> in_READ_QUEUE_IN_VAL            )) (*(READ_QUEUE_IN_VAL            ));
221  (*(_Read_queue->out_READ_QUEUE_IN_ACK            )) (*(READ_QUEUE_IN_ACK            ));
222  if(_param->_have_port_context_id   )
223    (*(_Read_queue-> in_READ_QUEUE_IN_CONTEXT_ID     )) (*(READ_QUEUE_IN_CONTEXT_ID     ));
224  if(_param->_have_port_front_end_id )
225    (*(_Read_queue-> in_READ_QUEUE_IN_FRONT_END_ID   )) (*(READ_QUEUE_IN_FRONT_END_ID   ));
226  if(_param->_have_port_ooo_engine_id)
227    (*(_Read_queue-> in_READ_QUEUE_IN_OOO_ENGINE_ID  )) (*(READ_QUEUE_IN_OOO_ENGINE_ID  ));
228  if(_param->_have_port_rob_id       )
229    (*(_Read_queue-> in_READ_QUEUE_IN_ROB_ID         )) (*(READ_QUEUE_IN_ROB_ID         ));
230  (*(_Read_queue-> in_READ_QUEUE_IN_OPERATION      )) (*(READ_QUEUE_IN_OPERATION      ));
231  (*(_Read_queue-> in_READ_QUEUE_IN_TYPE           )) (*(READ_QUEUE_IN_TYPE           ));
232  (*(_Read_queue-> in_READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE)) (*(READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE));
233  if (_param->_have_port_load_queue_ptr)
234  (*(_Read_queue-> in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE )) (*(READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ));
235  (*(_Read_queue-> in_READ_QUEUE_IN_HAS_IMMEDIAT   )) (*(READ_QUEUE_IN_HAS_IMMEDIAT   ));
236  (*(_Read_queue-> in_READ_QUEUE_IN_IMMEDIAT       )) (*(READ_QUEUE_IN_IMMEDIAT       ));
237  (*(_Read_queue-> in_READ_QUEUE_IN_READ_RA        )) (*(READ_QUEUE_IN_READ_RA        ));
238  (*(_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RA     )) (*(READ_QUEUE_IN_NUM_REG_RA     ));
239  (*(_Read_queue-> in_READ_QUEUE_IN_READ_RB        )) (*(READ_QUEUE_IN_READ_RB        ));
240  (*(_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RB     )) (*(READ_QUEUE_IN_NUM_REG_RB     ));
241  (*(_Read_queue-> in_READ_QUEUE_IN_READ_RC        )) (*(READ_QUEUE_IN_READ_RC        ));
242  (*(_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RC     )) (*(READ_QUEUE_IN_NUM_REG_RC     ));
243  (*(_Read_queue-> in_READ_QUEUE_IN_WRITE_RD       )) (*(READ_QUEUE_IN_WRITE_RD       ));
244  (*(_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RD     )) (*(READ_QUEUE_IN_NUM_REG_RD     ));
245  (*(_Read_queue-> in_READ_QUEUE_IN_WRITE_RE       )) (*(READ_QUEUE_IN_WRITE_RE       ));
246  (*(_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RE     )) (*(READ_QUEUE_IN_NUM_REG_RE     ));
247
248  (*(_Read_queue->out_READ_QUEUE_OUT_VAL           )) (*(READ_QUEUE_OUT_VAL           )); 
249  (*(_Read_queue-> in_READ_QUEUE_OUT_ACK           )) (*(READ_QUEUE_OUT_ACK           )); 
250  if(_param->_have_port_context_id   )
251    (*(_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID    )) (*(READ_QUEUE_OUT_CONTEXT_ID    )); 
252  if(_param->_have_port_front_end_id )
253    (*(_Read_queue->out_READ_QUEUE_OUT_FRONT_END_ID  )) (*(READ_QUEUE_OUT_FRONT_END_ID  )); 
254  if(_param->_have_port_ooo_engine_id)
255    (*(_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) (*(READ_QUEUE_OUT_OOO_ENGINE_ID )); 
256  if(_param->_have_port_rob_id       )
257    (*(_Read_queue->out_READ_QUEUE_OUT_ROB_ID        )) (*(READ_QUEUE_OUT_ROB_ID        )); 
258  (*(_Read_queue->out_READ_QUEUE_OUT_OPERATION     )) (*(READ_QUEUE_OUT_OPERATION     )); 
259  (*(_Read_queue->out_READ_QUEUE_OUT_TYPE          )) (*(READ_QUEUE_OUT_TYPE          )); 
260  (*(_Read_queue->out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE)) (*(READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE)); 
261  if (_param->_have_port_load_queue_ptr)
262  (*(_Read_queue->out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE )) (*(READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE )); 
263  (*(_Read_queue->out_READ_QUEUE_OUT_HAS_IMMEDIAT  )) (*(READ_QUEUE_OUT_HAS_IMMEDIAT  )); 
264  (*(_Read_queue->out_READ_QUEUE_OUT_IMMEDIAT      )) (*(READ_QUEUE_OUT_IMMEDIAT      )); 
265//   (*(_Read_queue->out_READ_QUEUE_OUT_READ_RA       )) (*(READ_QUEUE_OUT_READ_RA       ));
266  (*(_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RA    )) (*(READ_QUEUE_OUT_NUM_REG_RA    )); 
267  (*(_Read_queue->out_READ_QUEUE_OUT_DATA_RA_VAL   )) (*(READ_QUEUE_OUT_DATA_RA_VAL   )); 
268  (*(_Read_queue->out_READ_QUEUE_OUT_DATA_RA       )) (*(READ_QUEUE_OUT_DATA_RA       )); 
269//   (*(_Read_queue->out_READ_QUEUE_OUT_READ_RB       )) (*(READ_QUEUE_OUT_READ_RB       ));
270  (*(_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RB    )) (*(READ_QUEUE_OUT_NUM_REG_RB    )); 
271  (*(_Read_queue->out_READ_QUEUE_OUT_DATA_RB_VAL   )) (*(READ_QUEUE_OUT_DATA_RB_VAL   )); 
272  (*(_Read_queue->out_READ_QUEUE_OUT_DATA_RB       )) (*(READ_QUEUE_OUT_DATA_RB       )); 
273//   (*(_Read_queue->out_READ_QUEUE_OUT_READ_RC       )) (*(READ_QUEUE_OUT_READ_RC       ));
274  (*(_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RC    )) (*(READ_QUEUE_OUT_NUM_REG_RC    )); 
275  (*(_Read_queue->out_READ_QUEUE_OUT_DATA_RC_VAL   )) (*(READ_QUEUE_OUT_DATA_RC_VAL   )); 
276  (*(_Read_queue->out_READ_QUEUE_OUT_DATA_RC       )) (*(READ_QUEUE_OUT_DATA_RC       )); 
277  (*(_Read_queue->out_READ_QUEUE_OUT_WRITE_RD      )) (*(READ_QUEUE_OUT_WRITE_RD      )); 
278  (*(_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RD    )) (*(READ_QUEUE_OUT_NUM_REG_RD    )); 
279  (*(_Read_queue->out_READ_QUEUE_OUT_WRITE_RE      )) (*(READ_QUEUE_OUT_WRITE_RE      )); 
280  (*(_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RE    )) (*(READ_QUEUE_OUT_NUM_REG_RE    )); 
281
282  for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
283    {
284      (*(_Read_queue->out_GPR_READ_VAL         [i])) (*(GPR_READ_VAL         [i]));
285      (*(_Read_queue-> in_GPR_READ_ACK         [i])) (*(GPR_READ_ACK         [i]));
286      if(_param->_have_port_ooo_engine_id)
287        (*(_Read_queue->out_GPR_READ_OOO_ENGINE_ID  [i])) (*(GPR_READ_OOO_ENGINE_ID  [i]));
288      (*(_Read_queue->out_GPR_READ_NUM_REG     [i])) (*(GPR_READ_NUM_REG     [i]));
289      (*(_Read_queue-> in_GPR_READ_DATA        [i])) (*(GPR_READ_DATA        [i]));
290      (*(_Read_queue-> in_GPR_READ_DATA_VAL    [i])) (*(GPR_READ_DATA_VAL    [i]));
291    }
292 
293  for (uint32_t i=0; i<_param->_nb_spr_read; i++)
294    {
295      (*(_Read_queue->out_SPR_READ_VAL         [i])) (*(SPR_READ_VAL         [i]));
296      (*(_Read_queue-> in_SPR_READ_ACK         [i])) (*(SPR_READ_ACK         [i]));
297      if(_param->_have_port_ooo_engine_id)
298        (*(_Read_queue->out_SPR_READ_OOO_ENGINE_ID  [i])) (*(SPR_READ_OOO_ENGINE_ID  [i]));
299      (*(_Read_queue->out_SPR_READ_NUM_REG     [i])) (*(SPR_READ_NUM_REG     [i]));
300      (*(_Read_queue-> in_SPR_READ_DATA        [i])) (*(SPR_READ_DATA        [i]));
301      (*(_Read_queue-> in_SPR_READ_DATA_VAL    [i])) (*(SPR_READ_DATA_VAL    [i]));
302    }
303 
304  for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
305    {
306      (*(_Read_queue-> in_GPR_WRITE_VAL        [i])) (*(GPR_WRITE_VAL        [i]));
307      if(_param->_have_port_ooo_engine_id)
308        (*(_Read_queue-> in_GPR_WRITE_OOO_ENGINE_ID [i])) (*(GPR_WRITE_OOO_ENGINE_ID [i]));
309      (*(_Read_queue-> in_GPR_WRITE_NUM_REG    [i])) (*(GPR_WRITE_NUM_REG    [i]));
310      (*(_Read_queue-> in_GPR_WRITE_DATA       [i])) (*(GPR_WRITE_DATA       [i]));
311    }
312 
313  for (uint32_t i=0; i<_param->_nb_spr_write; i++)
314    {
315      (*(_Read_queue-> in_SPR_WRITE_VAL        [i])) (*(SPR_WRITE_VAL        [i]));
316      if(_param->_have_port_ooo_engine_id)
317        (*(_Read_queue-> in_SPR_WRITE_OOO_ENGINE_ID [i])) (*(SPR_WRITE_OOO_ENGINE_ID [i]));
318      (*(_Read_queue-> in_SPR_WRITE_NUM_REG    [i])) (*(SPR_WRITE_NUM_REG    [i]));
319      (*(_Read_queue-> in_SPR_WRITE_DATA       [i])) (*(SPR_WRITE_DATA       [i]));
320    }
321
322  cout << "<" << name << "> Start Simulation ............" << endl;
323  Time * _time = new Time();
324
325  /********************************************************
326   * Simulation - Begin
327   ********************************************************/
328
329  // Initialisation
330  const uint32_t nb_request = _param->_nb_packet;
331  // const uint32_t seed       = 0;
332  const uint32_t seed       = static_cast<uint32_t>(time(NULL));
333  srand(seed);
334
335  Tcontext_t         _ooo_engine_id [nb_request];
336  Tcontrol_t         _read_ra    [nb_request];
337  Tgeneral_address_t _num_reg_ra [nb_request];
338  Tcontrol_t         _read_rb    [nb_request];
339  Tgeneral_address_t _num_reg_rb [nb_request];
340  Tcontrol_t         _read_rc    [nb_request];
341  Tspecial_address_t _num_reg_rc [nb_request];
342
343  // emulation of registerFile
344  Tcontrol_t         _gpr_val    [_param->_nb_general_register][_param->_nb_ooo_engine];
345  Tgeneral_data_t    _gpr        [_param->_nb_general_register][_param->_nb_ooo_engine];
346  Tcontrol_t         _spr_val    [_param->_nb_special_register][_param->_nb_ooo_engine];
347  Tspecial_data_t    _spr        [_param->_nb_special_register][_param->_nb_ooo_engine];
348
349  SC_START(0);
350
351//   for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
352//     GPR_WRITE_VAL    [i]->write (0);
353//   for (uint32_t i=0; i<_param->_nb_spr_write; i++)
354//     SPR_WRITE_VAL    [i]->write (0);
355
356  NRESET->write(0);
357  SC_START(5);
358  NRESET->write(1);
359
360  LABEL("Loop of Test");
361
362  for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
363    {
364      LABEL("Iteration "+toString(iteration));
365      int32_t percent_transaction_queue_in     = (rand()%45)+30;
366      int32_t percent_transaction_queue_out    = (rand()%45)+30;
367      int32_t percent_registerfile_valid       = (rand()%45)+30;
368      int32_t percent_transaction_registerfile = (rand()%45)+30;
369      int32_t percent_transaction_bypass       = (rand()%45)+30;
370      int32_t percent_must_read_reg            = (rand()%45)+30;
371
372      LABEL("Initialisation");
373
374      for (uint32_t i=0; i<nb_request; i++)
375        {
376          _ooo_engine_id   [i] = rand()% _param->_nb_ooo_engine         ;
377          _read_ra      [i] = (rand()%100)<percent_must_read_reg;
378          _num_reg_ra   [i] = rand()% _param->_nb_general_register   ;
379          _read_rb      [i] = (rand()%100)<percent_must_read_reg;
380          _num_reg_rb   [i] = rand()% _param->_nb_general_register   ;
381          _read_rc      [i] = (rand()%100)<percent_must_read_reg;
382          _num_reg_rc   [i] = rand()% _param->_nb_special_register   ;
383        }
384     
385      // emulation of registerFile
386      for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
387        {
388          for (uint32_t i=0; i<_param->_nb_general_register; i++)
389            {
390              _gpr_val      [i][j] = ((rand()%100) < percent_registerfile_valid);
391              _gpr          [i][j] = rand()%(1<<_param->_size_general_data);
392            }
393          for (uint32_t i=0; i<_param->_nb_special_register; i++)
394            {
395              _spr_val      [i][j] = ((rand()%100) < percent_registerfile_valid);
396              _spr          [i][j] = rand()%(1<<_param->_size_special_data);
397            }
398        }
399      // End initialisation .......
400     
401      uint32_t request_in  = 0;
402      uint32_t request_out = 0;
403
404      while (request_out < nb_request)
405        {
406          if ((request_in < nb_request) and
407              ((rand()%100) < percent_transaction_queue_in))
408            {
409              READ_QUEUE_IN_VAL            ->write(1);
410              if(_param->_have_port_ooo_engine_id)
411                READ_QUEUE_IN_OOO_ENGINE_ID  ->write(_ooo_engine_id [request_in]);
412              if(_param->_have_port_context_id   )
413                READ_QUEUE_IN_CONTEXT_ID     ->write((2*_ooo_engine_id [request_in])%_param->_nb_context  );
414              if(_param->_have_port_front_end_id )
415                READ_QUEUE_IN_FRONT_END_ID   ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
416              if(_param->_have_port_rob_id       )
417                READ_QUEUE_IN_ROB_ID      ->write(request_in);
418              READ_QUEUE_IN_OPERATION   ->write(0);
419              READ_QUEUE_IN_TYPE        ->write(0);
420              READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE->write(0);
421              if (_param->_have_port_load_queue_ptr)
422              READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ->write(0);
423              READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
424              READ_QUEUE_IN_IMMEDIAT    ->write(0);
425              READ_QUEUE_IN_READ_RA     ->write(_read_ra    [request_in]);
426              READ_QUEUE_IN_NUM_REG_RA  ->write(_num_reg_ra [request_in]);
427              READ_QUEUE_IN_READ_RB     ->write(_read_rb    [request_in]);
428              READ_QUEUE_IN_NUM_REG_RB  ->write(_num_reg_rb [request_in]);
429              READ_QUEUE_IN_READ_RC     ->write(_read_rc    [request_in]);
430              READ_QUEUE_IN_NUM_REG_RC  ->write(_num_reg_rc [request_in]);
431              READ_QUEUE_IN_WRITE_RD    ->write(0);
432              READ_QUEUE_IN_NUM_REG_RD  ->write(0);
433              READ_QUEUE_IN_WRITE_RE    ->write(0);
434              READ_QUEUE_IN_NUM_REG_RE  ->write(0);
435            }
436          else
437            {
438              READ_QUEUE_IN_VAL         ->write(0);
439            }
440
441          READ_QUEUE_OUT_ACK         ->write((rand()%100) < percent_transaction_queue_out);
442                 
443          // RegisterFile access
444          for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
445            {
446              GPR_READ_ACK      [i]->write((rand()%100) < percent_transaction_registerfile);
447              if (GPR_READ_VAL [i]->read())
448                {
449                  Tgeneral_address_t num_reg = GPR_READ_NUM_REG       [i]->read();
450                  Tcontext_t         ooo_engine;
451                  if(_param->_have_port_ooo_engine_id)
452                    ooo_engine = GPR_READ_OOO_ENGINE_ID [i]->read();
453                  else
454                    ooo_engine = 0;
455
456                  GPR_READ_DATA     [i]->write(_gpr    [num_reg][ooo_engine]);
457                  GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][ooo_engine]);
458                }
459            }
460          for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
461            {
462              SPR_READ_ACK      [i]->write((rand()%100) < percent_transaction_registerfile);
463
464              if (SPR_READ_VAL [i]->read())
465                {
466                  Tspecial_address_t num_reg = SPR_READ_NUM_REG       [i]->read();
467                  Tcontext_t         ooo_engine;
468                  if(_param->_have_port_ooo_engine_id)
469                    ooo_engine = SPR_READ_OOO_ENGINE_ID [i]->read();
470                  else
471                    ooo_engine = 0;
472
473                  SPR_READ_DATA     [i]->write(_spr    [num_reg][ooo_engine]);
474                  SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][ooo_engine]);
475                }
476            }
477
478          // BYPASS
479          for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
480            {
481              Tcontrol_t         val     = (rand()%100) < percent_transaction_bypass;
482              Tcontext_t         ooo_engine = rand()% _param->_nb_ooo_engine;
483              Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
484              Tgeneral_data_t    data    = rand()%(1<<_param->_size_general_data);
485             
486              GPR_WRITE_VAL           [i]->write(val);       
487              if(_param->_have_port_ooo_engine_id)
488                GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
489              GPR_WRITE_NUM_REG       [i]->write(num_reg);
490              GPR_WRITE_DATA          [i]->write(data);
491
492              if (val)
493                {
494                  _gpr     [num_reg][ooo_engine] = data;
495                  _gpr_val [num_reg][ooo_engine] = 1;
496                }
497            }
498          for (uint32_t i=0; i<_param->_nb_spr_write; i++)
499            {
500              Tcontrol_t         val     = (rand()%100) < percent_transaction_bypass;
501              Tcontext_t         ooo_engine = rand()% _param->_nb_ooo_engine;
502              Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
503              Tspecial_data_t    data    = rand()%(1<<_param->_size_special_data);
504             
505              SPR_WRITE_VAL            [i]->write(val);       
506              if(_param->_have_port_ooo_engine_id)
507                SPR_WRITE_OOO_ENGINE_ID  [i]->write(ooo_engine);
508              SPR_WRITE_NUM_REG        [i]->write(num_reg);
509              SPR_WRITE_DATA           [i]->write(data);
510
511              if (val)
512                {
513                  _spr     [num_reg][ooo_engine] = data;
514                  _spr_val [num_reg][ooo_engine] = 1;
515                }
516            }
517
518          SC_START(0);
519         
520          LABEL("Test     READ_QUEUE_IN  : "+toString(READ_QUEUE_IN_VAL->read())+","+toString(READ_QUEUE_IN_ACK->read()));
521          if ((READ_QUEUE_IN_VAL->read() == 1) and
522              (READ_QUEUE_IN_ACK->read() == 1))
523            {
524              LABEL("Accepted READ_QUEUE_IN  ["+toString(request_in)+"]");
525              request_in  ++;
526            }
527          LABEL("Test     READ_QUEUE_OUT : "+toString(READ_QUEUE_OUT_VAL->read())+","+toString(READ_QUEUE_OUT_ACK->read()));
528          if ((READ_QUEUE_OUT_VAL->read() == 1) and
529              (READ_QUEUE_OUT_ACK->read() == 1))
530            {
531              Tpacket_t  rob_id;
532              if(_param->_have_port_rob_id       )
533                rob_id = READ_QUEUE_OUT_ROB_ID->read();
534              else
535                rob_id = 0;
536              Tcontext_t ctxt   = _ooo_engine_id [rob_id];
537              LABEL("Accepted READ_QUEUE_OUT ["+toString(rob_id)+"]");
538             
539              TEST(uint32_t          , rob_id ,request_out);
540             
541              request_out ++;
542
543              if(_param->_have_port_ooo_engine_id)
544                TEST(Tcontext_t        ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
545              if(_param->_have_port_context_id   )
546                TEST(Tcontext_t        ,READ_QUEUE_OUT_CONTEXT_ID    ->read(),(2*ctxt)%_param->_nb_context  );
547              if(_param->_have_port_front_end_id )
548                TEST(Tcontext_t        ,READ_QUEUE_OUT_FRONT_END_ID  ->read(),(3*ctxt)%_param->_nb_front_end);
549
550//            TEST(Tcontrol_t        ,READ_QUEUE_OUT_READ_RA    ->read(),_read_ra      [rob_id]);
551              TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RA ->read(),_num_reg_ra   [rob_id]);
552              TEST(Tcontrol_t        ,READ_QUEUE_OUT_DATA_RA_VAL->read(),not _read_ra [rob_id] or _gpr_val [_num_reg_ra[rob_id]][ctxt]);
553              if (_read_ra [rob_id] and
554                  READ_QUEUE_OUT_DATA_RA_VAL->read())
555              TEST(Tgeneral_data_t   ,READ_QUEUE_OUT_DATA_RA    ->read(),_gpr          [_num_reg_ra[rob_id]][ctxt]);
556//            TEST(Tcontrol_t        ,READ_QUEUE_OUT_READ_RB    ->read(),_read_rb      [rob_id]);
557              TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RB ->read(),_num_reg_rb   [rob_id]);
558              TEST(Tcontrol_t        ,READ_QUEUE_OUT_DATA_RB_VAL->read(),not _read_rb [rob_id] or _gpr_val [_num_reg_rb[rob_id]][ctxt]);
559              if (_read_rb [rob_id] and
560                  READ_QUEUE_OUT_DATA_RB_VAL->read())
561              TEST(Tgeneral_data_t   ,READ_QUEUE_OUT_DATA_RB    ->read(),_gpr          [_num_reg_rb[rob_id]][ctxt]);
562//            TEST(Tcontrol_t        ,READ_QUEUE_OUT_READ_RC    ->read(),_read_rc      [rob_id]);
563              TEST(Tspecial_address_t,READ_QUEUE_OUT_NUM_REG_RC ->read(),_num_reg_rc   [rob_id]);
564              TEST(Tcontrol_t        ,READ_QUEUE_OUT_DATA_RC_VAL->read(),not _read_rc [rob_id] or _spr_val [_num_reg_rc[rob_id]][ctxt]);
565              if (_read_rc [rob_id] and
566                  READ_QUEUE_OUT_DATA_RC_VAL->read())
567              TEST(Tspecial_data_t   ,READ_QUEUE_OUT_DATA_RC    ->read(),_spr     [_num_reg_rc[rob_id]][ctxt]);
568            }
569          SC_START(1);
570        }
571    }
572
573  /********************************************************
574   * Simulation - End
575   ********************************************************/
576
577  TEST_OK ("End of Simulation");
578  delete _time;
579  cout << "<" << name << "> ............ Stop Simulation" << endl;
580
581   delete    CLOCK;
582   delete    NRESET;
583
584   delete    READ_QUEUE_IN_VAL          ;
585   delete    READ_QUEUE_IN_ACK          ;
586   if(_param->_have_port_context_id   )
587     delete    READ_QUEUE_IN_CONTEXT_ID   ;
588   if(_param->_have_port_front_end_id )
589     delete    READ_QUEUE_IN_FRONT_END_ID;
590   if(_param->_have_port_ooo_engine_id )
591     delete    READ_QUEUE_IN_OOO_ENGINE_ID;
592   if(_param->_have_port_rob_id       )
593     delete    READ_QUEUE_IN_ROB_ID    ;
594   delete    READ_QUEUE_IN_OPERATION    ;
595   delete    READ_QUEUE_IN_TYPE         ;
596   delete    READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
597   if (_param->_have_port_load_queue_ptr)
598   delete    READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
599   delete    READ_QUEUE_IN_HAS_IMMEDIAT ;
600   delete    READ_QUEUE_IN_IMMEDIAT     ;
601   delete    READ_QUEUE_IN_READ_RA      ;
602   delete    READ_QUEUE_IN_NUM_REG_RA   ;
603   delete    READ_QUEUE_IN_READ_RB      ;
604   delete    READ_QUEUE_IN_NUM_REG_RB   ;
605   delete    READ_QUEUE_IN_READ_RC      ;
606   delete    READ_QUEUE_IN_NUM_REG_RC   ;
607   delete    READ_QUEUE_IN_WRITE_RD     ;
608   delete    READ_QUEUE_IN_NUM_REG_RD   ;
609   delete    READ_QUEUE_IN_WRITE_RE     ;
610   delete    READ_QUEUE_IN_NUM_REG_RE   ;
611
612   delete    READ_QUEUE_OUT_VAL         ;
613   delete    READ_QUEUE_OUT_ACK         ;
614   if(_param->_have_port_context_id   )
615     delete    READ_QUEUE_OUT_CONTEXT_ID  ;
616   if(_param->_have_port_front_end_id )
617     delete    READ_QUEUE_OUT_FRONT_END_ID;
618   if(_param->_have_port_ooo_engine_id )
619     delete    READ_QUEUE_OUT_OOO_ENGINE_ID;
620   if(_param->_have_port_rob_id       )
621     delete    READ_QUEUE_OUT_ROB_ID      ;
622   delete    READ_QUEUE_OUT_OPERATION   ;
623   delete    READ_QUEUE_OUT_TYPE        ;
624   delete    READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
625   if (_param->_have_port_load_queue_ptr)
626   delete    READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
627   delete    READ_QUEUE_OUT_HAS_IMMEDIAT;
628   delete    READ_QUEUE_OUT_IMMEDIAT    ;
629   delete    READ_QUEUE_OUT_READ_RA     ;
630   delete    READ_QUEUE_OUT_NUM_REG_RA  ;
631   delete    READ_QUEUE_OUT_DATA_RA_VAL ;
632   delete    READ_QUEUE_OUT_DATA_RA     ;
633   delete    READ_QUEUE_OUT_READ_RB     ;
634   delete    READ_QUEUE_OUT_NUM_REG_RB  ;
635   delete    READ_QUEUE_OUT_DATA_RB_VAL ;
636   delete    READ_QUEUE_OUT_DATA_RB     ;
637   delete    READ_QUEUE_OUT_READ_RC     ;
638   delete    READ_QUEUE_OUT_NUM_REG_RC  ;
639   delete    READ_QUEUE_OUT_DATA_RC_VAL ;
640   delete    READ_QUEUE_OUT_DATA_RC     ;
641   delete    READ_QUEUE_OUT_WRITE_RD    ;
642   delete    READ_QUEUE_OUT_NUM_REG_RD  ;
643   delete    READ_QUEUE_OUT_WRITE_RE    ;
644   delete    READ_QUEUE_OUT_NUM_REG_RE  ;
645
646   delete [] GPR_READ_VAL     ;
647   delete [] GPR_READ_ACK     ;
648   delete [] GPR_READ_NUM_REG ;
649   delete [] GPR_READ_DATA    ;
650   delete [] GPR_READ_DATA_VAL;
651   if(_param->_have_port_ooo_engine_id )
652     delete [] GPR_READ_OOO_ENGINE_ID ;
653
654   delete [] SPR_READ_VAL     ;
655   delete [] SPR_READ_ACK     ;
656   delete [] SPR_READ_NUM_REG ;
657   delete [] SPR_READ_DATA    ;
658   delete [] SPR_READ_DATA_VAL;
659   if(_param->_have_port_ooo_engine_id )
660     delete [] SPR_READ_OOO_ENGINE_ID ;
661
662   delete [] GPR_WRITE_VAL        ;
663   if(_param->_have_port_ooo_engine_id )
664     delete [] GPR_WRITE_OOO_ENGINE_ID ;
665   delete [] GPR_WRITE_NUM_REG    ;
666   delete [] GPR_WRITE_DATA       ;
667
668   delete [] SPR_WRITE_VAL        ;
669   if(_param->_have_port_ooo_engine_id )
670     delete [] SPR_WRITE_OOO_ENGINE_ID ;
671   delete [] SPR_WRITE_NUM_REG    ;
672   delete [] SPR_WRITE_DATA       ;
673#endif
674
675  delete _Read_queue;
676
677#ifdef STATISTICS
678  delete _parameters_statistics;
679#endif
680}
Note: See TracBrowser for help on using the repository browser.