Context Navigation

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

Last change on this file since 76 was 76, checked in by rosiere, 16 years ago
Add new component : Read_unit (no tested) Change functionnal_unit : now use type and operation to execute the good function Change New_Component's script
File size: 36.6 KB

Line
1	/*
2	* $Id$
3	*
4	* [ Description ]
5	*
6	* Test
7	*/
8
9	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/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
21	static uint32_t cycle = 0;
22
23	#define SC_START(cycle_offset) \
24	do \
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
43	void 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	((_Read_queue-> in_READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE )) ((READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ));
234	((_Read_queue-> in_READ_QUEUE_IN_HAS_IMMEDIAT )) ((READ_QUEUE_IN_HAS_IMMEDIAT ));
235	((_Read_queue-> in_READ_QUEUE_IN_IMMEDIAT )) ((READ_QUEUE_IN_IMMEDIAT ));
236	((_Read_queue-> in_READ_QUEUE_IN_READ_RA )) ((READ_QUEUE_IN_READ_RA ));
237	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RA )) ((READ_QUEUE_IN_NUM_REG_RA ));
238	((_Read_queue-> in_READ_QUEUE_IN_READ_RB )) ((READ_QUEUE_IN_READ_RB ));
239	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RB )) ((READ_QUEUE_IN_NUM_REG_RB ));
240	((_Read_queue-> in_READ_QUEUE_IN_READ_RC )) ((READ_QUEUE_IN_READ_RC ));
241	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RC )) ((READ_QUEUE_IN_NUM_REG_RC ));
242	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RD )) ((READ_QUEUE_IN_WRITE_RD ));
243	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RD )) ((READ_QUEUE_IN_NUM_REG_RD ));
244	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RE )) ((READ_QUEUE_IN_WRITE_RE ));
245	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RE )) ((READ_QUEUE_IN_NUM_REG_RE ));
246
247	((_Read_queue->out_READ_QUEUE_OUT_VAL )) ((READ_QUEUE_OUT_VAL ));
248	((_Read_queue-> in_READ_QUEUE_OUT_ACK )) ((READ_QUEUE_OUT_ACK ));
249	if(_param->_have_port_context_id )
250	((_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID )) ((READ_QUEUE_OUT_CONTEXT_ID ));
251	if(_param->_have_port_front_end_id )
252	((_Read_queue->out_READ_QUEUE_OUT_FRONT_END_ID )) ((READ_QUEUE_OUT_FRONT_END_ID ));
253	if(_param->_have_port_ooo_engine_id)
254	((_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) ((READ_QUEUE_OUT_OOO_ENGINE_ID ));
255	if(_param->_have_port_rob_id )
256	((_Read_queue->out_READ_QUEUE_OUT_ROB_ID )) ((READ_QUEUE_OUT_ROB_ID ));
257	((_Read_queue->out_READ_QUEUE_OUT_OPERATION )) ((READ_QUEUE_OUT_OPERATION ));
258	((_Read_queue->out_READ_QUEUE_OUT_TYPE )) ((READ_QUEUE_OUT_TYPE ));
259	((_Read_queue->out_READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE)) ((READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE));
260	((_Read_queue->out_READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE )) ((READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ));
261	((_Read_queue->out_READ_QUEUE_OUT_HAS_IMMEDIAT )) ((READ_QUEUE_OUT_HAS_IMMEDIAT ));
262	((_Read_queue->out_READ_QUEUE_OUT_IMMEDIAT )) ((READ_QUEUE_OUT_IMMEDIAT ));
263	// ((_Read_queue->out_READ_QUEUE_OUT_READ_RA )) ((READ_QUEUE_OUT_READ_RA ));
264	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RA )) ((READ_QUEUE_OUT_NUM_REG_RA ));
265	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA_VAL )) ((READ_QUEUE_OUT_DATA_RA_VAL ));
266	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA )) ((READ_QUEUE_OUT_DATA_RA ));
267	// ((_Read_queue->out_READ_QUEUE_OUT_READ_RB )) ((READ_QUEUE_OUT_READ_RB ));
268	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RB )) ((READ_QUEUE_OUT_NUM_REG_RB ));
269	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB_VAL )) ((READ_QUEUE_OUT_DATA_RB_VAL ));
270	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB )) ((READ_QUEUE_OUT_DATA_RB ));
271	// ((_Read_queue->out_READ_QUEUE_OUT_READ_RC )) ((READ_QUEUE_OUT_READ_RC ));
272	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RC )) ((READ_QUEUE_OUT_NUM_REG_RC ));
273	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC_VAL )) ((READ_QUEUE_OUT_DATA_RC_VAL ));
274	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC )) ((READ_QUEUE_OUT_DATA_RC ));
275	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RD )) ((READ_QUEUE_OUT_WRITE_RD ));
276	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RD )) ((READ_QUEUE_OUT_NUM_REG_RD ));
277	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RE )) ((READ_QUEUE_OUT_WRITE_RE ));
278	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RE )) ((READ_QUEUE_OUT_NUM_REG_RE ));
279
280	for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
281	{
282	((_Read_queue->out_GPR_READ_VAL [i])) ((GPR_READ_VAL [i]));
283	((_Read_queue-> in_GPR_READ_ACK [i])) ((GPR_READ_ACK [i]));
284	if(_param->_have_port_ooo_engine_id)
285	((_Read_queue->out_GPR_READ_OOO_ENGINE_ID [i])) ((GPR_READ_OOO_ENGINE_ID [i]));
286	((_Read_queue->out_GPR_READ_NUM_REG [i])) ((GPR_READ_NUM_REG [i]));
287	((_Read_queue-> in_GPR_READ_DATA [i])) ((GPR_READ_DATA [i]));
288	((_Read_queue-> in_GPR_READ_DATA_VAL [i])) ((GPR_READ_DATA_VAL [i]));
289	}
290
291	for (uint32_t i=0; i<_param->_nb_spr_read; i++)
292	{
293	((_Read_queue->out_SPR_READ_VAL [i])) ((SPR_READ_VAL [i]));
294	((_Read_queue-> in_SPR_READ_ACK [i])) ((SPR_READ_ACK [i]));
295	if(_param->_have_port_ooo_engine_id)
296	((_Read_queue->out_SPR_READ_OOO_ENGINE_ID [i])) ((SPR_READ_OOO_ENGINE_ID [i]));
297	((_Read_queue->out_SPR_READ_NUM_REG [i])) ((SPR_READ_NUM_REG [i]));
298	((_Read_queue-> in_SPR_READ_DATA [i])) ((SPR_READ_DATA [i]));
299	((_Read_queue-> in_SPR_READ_DATA_VAL [i])) ((SPR_READ_DATA_VAL [i]));
300	}
301
302	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
303	{
304	((_Read_queue-> in_GPR_WRITE_VAL [i])) ((GPR_WRITE_VAL [i]));
305	if(_param->_have_port_ooo_engine_id)
306	((_Read_queue-> in_GPR_WRITE_OOO_ENGINE_ID [i])) ((GPR_WRITE_OOO_ENGINE_ID [i]));
307	((_Read_queue-> in_GPR_WRITE_NUM_REG [i])) ((GPR_WRITE_NUM_REG [i]));
308	((_Read_queue-> in_GPR_WRITE_DATA [i])) ((GPR_WRITE_DATA [i]));
309	}
310
311	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
312	{
313	((_Read_queue-> in_SPR_WRITE_VAL [i])) ((SPR_WRITE_VAL [i]));
314	if(_param->_have_port_ooo_engine_id)
315	((_Read_queue-> in_SPR_WRITE_OOO_ENGINE_ID [i])) ((SPR_WRITE_OOO_ENGINE_ID [i]));
316	((_Read_queue-> in_SPR_WRITE_NUM_REG [i])) ((SPR_WRITE_NUM_REG [i]));
317	((_Read_queue-> in_SPR_WRITE_DATA [i])) ((SPR_WRITE_DATA [i]));
318	}
319
320	cout << "<" << name << "> Start Simulation ............" << endl;
321	Time * _time = new Time();
322
323	/********************************************************
324	* Simulation - Begin
325	********************************************************/
326
327	// Initialisation
328	const uint32_t nb_request = _param->_nb_packet;
329	// const uint32_t seed = 0;
330	const uint32_t seed = static_cast<uint32_t>(time(NULL));
331	srand(seed);
332
333	Tcontext_t _ooo_engine_id [nb_request];
334	Tcontrol_t _read_ra [nb_request];
335	Tgeneral_address_t _num_reg_ra [nb_request];
336	Tcontrol_t _read_rb [nb_request];
337	Tgeneral_address_t _num_reg_rb [nb_request];
338	Tcontrol_t _read_rc [nb_request];
339	Tspecial_address_t _num_reg_rc [nb_request];
340
341	// emulation of registerFile
342	Tcontrol_t _gpr_val [_param->_nb_general_register][_param->_nb_ooo_engine];
343	Tgeneral_data_t _gpr [_param->_nb_general_register][_param->_nb_ooo_engine];
344	Tcontrol_t _spr_val [_param->_nb_special_register][_param->_nb_ooo_engine];
345	Tspecial_data_t _spr [_param->_nb_special_register][_param->_nb_ooo_engine];
346
347	SC_START(0);
348
349	// for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
350	// GPR_WRITE_VAL [i]->write (0);
351	// for (uint32_t i=0; i<_param->_nb_spr_write; i++)
352	// SPR_WRITE_VAL [i]->write (0);
353
354	NRESET->write(0);
355	SC_START(5);
356	NRESET->write(1);
357
358	LABEL("Loop of Test");
359
360	for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
361	{
362	LABEL("Iteration "+toString(iteration));
363	int32_t percent_transaction_queue_in = (rand()%45)+30;
364	int32_t percent_transaction_queue_out = (rand()%45)+30;
365	int32_t percent_registerfile_valid = (rand()%45)+30;
366	int32_t percent_transaction_registerfile = (rand()%45)+30;
367	int32_t percent_transaction_bypass = (rand()%45)+30;
368	int32_t percent_must_read_reg = (rand()%45)+30;
369
370	LABEL("Initialisation");
371
372	for (uint32_t i=0; i<nb_request; i++)
373	{
374	_ooo_engine_id [i] = rand()% _param->_nb_ooo_engine ;
375	_read_ra [i] = (rand()%100)<percent_must_read_reg;
376	_num_reg_ra [i] = rand()% _param->_nb_general_register ;
377	_read_rb [i] = (rand()%100)<percent_must_read_reg;
378	_num_reg_rb [i] = rand()% _param->_nb_general_register ;
379	_read_rc [i] = (rand()%100)<percent_must_read_reg;
380	_num_reg_rc [i] = rand()% _param->_nb_special_register ;
381	}
382
383	// emulation of registerFile
384	for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
385	{
386	for (uint32_t i=0; i<_param->_nb_general_register; i++)
387	{
388	_gpr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
389	_gpr [i][j] = rand()%(1<<_param->_size_general_data);
390	}
391	for (uint32_t i=0; i<_param->_nb_special_register; i++)
392	{
393	_spr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
394	_spr [i][j] = rand()%(1<<_param->_size_special_data);
395	}
396	}
397	// End initialisation .......
398
399	uint32_t request_in = 0;
400	uint32_t request_out = 0;
401
402	while (request_out < nb_request)
403	{
404	if ((request_in < nb_request) and
405	((rand()%100) < percent_transaction_queue_in))
406	{
407	READ_QUEUE_IN_VAL ->write(1);
408	if(_param->_have_port_ooo_engine_id)
409	READ_QUEUE_IN_OOO_ENGINE_ID ->write(_ooo_engine_id [request_in]);
410	if(_param->_have_port_context_id )
411	READ_QUEUE_IN_CONTEXT_ID ->write((2*_ooo_engine_id [request_in])%_param->_nb_context );
412	if(_param->_have_port_front_end_id )
413	READ_QUEUE_IN_FRONT_END_ID ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
414	if(_param->_have_port_rob_id )
415	READ_QUEUE_IN_ROB_ID ->write(request_in);
416	READ_QUEUE_IN_OPERATION ->write(0);
417	READ_QUEUE_IN_TYPE ->write(0);
418	READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE->write(0);
419	READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ->write(0);
420	READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
421	READ_QUEUE_IN_IMMEDIAT ->write(0);
422	READ_QUEUE_IN_READ_RA ->write(_read_ra [request_in]);
423	READ_QUEUE_IN_NUM_REG_RA ->write(_num_reg_ra [request_in]);
424	READ_QUEUE_IN_READ_RB ->write(_read_rb [request_in]);
425	READ_QUEUE_IN_NUM_REG_RB ->write(_num_reg_rb [request_in]);
426	READ_QUEUE_IN_READ_RC ->write(_read_rc [request_in]);
427	READ_QUEUE_IN_NUM_REG_RC ->write(_num_reg_rc [request_in]);
428	READ_QUEUE_IN_WRITE_RD ->write(0);
429	READ_QUEUE_IN_NUM_REG_RD ->write(0);
430	READ_QUEUE_IN_WRITE_RE ->write(0);
431	READ_QUEUE_IN_NUM_REG_RE ->write(0);
432	}
433	else
434	{
435	READ_QUEUE_IN_VAL ->write(0);
436	}
437
438	READ_QUEUE_OUT_ACK ->write((rand()%100) < percent_transaction_queue_out);
439
440	// RegisterFile access
441	for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
442	{
443	GPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
444	if (GPR_READ_VAL [i]->read())
445	{
446	Tgeneral_address_t num_reg = GPR_READ_NUM_REG [i]->read();
447	Tcontext_t ooo_engine;
448	if(_param->_have_port_ooo_engine_id)
449	ooo_engine = GPR_READ_OOO_ENGINE_ID [i]->read();
450	else
451	ooo_engine = 0;
452
453	GPR_READ_DATA [i]->write(_gpr [num_reg][ooo_engine]);
454	GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][ooo_engine]);
455	}
456	}
457	for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
458	{
459	SPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
460
461	if (SPR_READ_VAL [i]->read())
462	{
463	Tspecial_address_t num_reg = SPR_READ_NUM_REG [i]->read();
464	Tcontext_t ooo_engine;
465	if(_param->_have_port_ooo_engine_id)
466	ooo_engine = SPR_READ_OOO_ENGINE_ID [i]->read();
467	else
468	ooo_engine = 0;
469
470	SPR_READ_DATA [i]->write(_spr [num_reg][ooo_engine]);
471	SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][ooo_engine]);
472	}
473	}
474
475	// BYPASS
476	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
477	{
478	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
479	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
480	Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
481	Tgeneral_data_t data = rand()%(1<<_param->_size_general_data);
482
483	GPR_WRITE_VAL [i]->write(val);
484	if(_param->_have_port_ooo_engine_id)
485	GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
486	GPR_WRITE_NUM_REG [i]->write(num_reg);
487	GPR_WRITE_DATA [i]->write(data);
488
489	if (val)
490	{
491	_gpr [num_reg][ooo_engine] = data;
492	_gpr_val [num_reg][ooo_engine] = 1;
493	}
494	}
495	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
496	{
497	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
498	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
499	Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
500	Tspecial_data_t data = rand()%(1<<_param->_size_special_data);
501
502	SPR_WRITE_VAL [i]->write(val);
503	if(_param->_have_port_ooo_engine_id)
504	SPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
505	SPR_WRITE_NUM_REG [i]->write(num_reg);
506	SPR_WRITE_DATA [i]->write(data);
507
508	if (val)
509	{
510	_spr [num_reg][ooo_engine] = data;
511	_spr_val [num_reg][ooo_engine] = 1;
512	}
513	}
514
515	SC_START(0);
516
517	LABEL("Test READ_QUEUE_IN : "+toString(READ_QUEUE_IN_VAL->read())+","+toString(READ_QUEUE_IN_ACK->read()));
518	if ((READ_QUEUE_IN_VAL->read() == 1) and
519	(READ_QUEUE_IN_ACK->read() == 1))
520	{
521	LABEL("Accepted READ_QUEUE_IN ["+toString(request_in)+"]");
522	request_in ++;
523	}
524	LABEL("Test READ_QUEUE_OUT : "+toString(READ_QUEUE_OUT_VAL->read())+","+toString(READ_QUEUE_OUT_ACK->read()));
525	if ((READ_QUEUE_OUT_VAL->read() == 1) and
526	(READ_QUEUE_OUT_ACK->read() == 1))
527	{
528	Tpacket_t rob_id;
529	if(_param->_have_port_rob_id )
530	rob_id = READ_QUEUE_OUT_ROB_ID->read();
531	else
532	rob_id = 0;
533	Tcontext_t ctxt = _ooo_engine_id [rob_id];
534	LABEL("Accepted READ_QUEUE_OUT ["+toString(rob_id)+"]");
535
536	TEST(uint32_t , rob_id ,request_out);
537
538	request_out ++;
539
540	if(_param->_have_port_ooo_engine_id)
541	TEST(Tcontext_t ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
542	if(_param->_have_port_context_id )
543	TEST(Tcontext_t ,READ_QUEUE_OUT_CONTEXT_ID ->read(),(2*ctxt)%_param->_nb_context );
544	if(_param->_have_port_front_end_id )
545	TEST(Tcontext_t ,READ_QUEUE_OUT_FRONT_END_ID ->read(),(3*ctxt)%_param->_nb_front_end);
546
547	// TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RA ->read(),_read_ra [rob_id]);
548	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RA ->read(),_num_reg_ra [rob_id]);
549	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RA_VAL->read(),not _read_ra [rob_id] or _gpr_val [_num_reg_ra[rob_id]][ctxt]);
550	if (_read_ra [rob_id] and
551	READ_QUEUE_OUT_DATA_RA_VAL->read())
552	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RA ->read(),_gpr [_num_reg_ra[rob_id]][ctxt]);
553	// TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RB ->read(),_read_rb [rob_id]);
554	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RB ->read(),_num_reg_rb [rob_id]);
555	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RB_VAL->read(),not _read_rb [rob_id] or _gpr_val [_num_reg_rb[rob_id]][ctxt]);
556	if (_read_rb [rob_id] and
557	READ_QUEUE_OUT_DATA_RB_VAL->read())
558	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RB ->read(),_gpr [_num_reg_rb[rob_id]][ctxt]);
559	// TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RC ->read(),_read_rc [rob_id]);
560	TEST(Tspecial_address_t,READ_QUEUE_OUT_NUM_REG_RC ->read(),_num_reg_rc [rob_id]);
561	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RC_VAL->read(),not _read_rc [rob_id] or _spr_val [_num_reg_rc[rob_id]][ctxt]);
562	if (_read_rc [rob_id] and
563	READ_QUEUE_OUT_DATA_RC_VAL->read())
564	TEST(Tspecial_data_t ,READ_QUEUE_OUT_DATA_RC ->read(),_spr [_num_reg_rc[rob_id]][ctxt]);
565	}
566	SC_START(1);
567	}
568	}
569
570	/********************************************************
571	* Simulation - End
572	********************************************************/
573
574	TEST_OK ("End of Simulation");
575	delete _time;
576	cout << "<" << name << "> ............ Stop Simulation" << endl;
577
578	delete CLOCK;
579	delete NRESET;
580
581	delete READ_QUEUE_IN_VAL ;
582	delete READ_QUEUE_IN_ACK ;
583	if(_param->_have_port_context_id )
584	delete READ_QUEUE_IN_CONTEXT_ID ;
585	if(_param->_have_port_front_end_id )
586	delete READ_QUEUE_IN_FRONT_END_ID;
587	if(_param->_have_port_ooo_engine_id )
588	delete READ_QUEUE_IN_OOO_ENGINE_ID;
589	if(_param->_have_port_rob_id )
590	delete READ_QUEUE_IN_ROB_ID ;
591	delete READ_QUEUE_IN_OPERATION ;
592	delete READ_QUEUE_IN_TYPE ;
593	delete READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
594	delete READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
595	delete READ_QUEUE_IN_HAS_IMMEDIAT ;
596	delete READ_QUEUE_IN_IMMEDIAT ;
597	delete READ_QUEUE_IN_READ_RA ;
598	delete READ_QUEUE_IN_NUM_REG_RA ;
599	delete READ_QUEUE_IN_READ_RB ;
600	delete READ_QUEUE_IN_NUM_REG_RB ;
601	delete READ_QUEUE_IN_READ_RC ;
602	delete READ_QUEUE_IN_NUM_REG_RC ;
603	delete READ_QUEUE_IN_WRITE_RD ;
604	delete READ_QUEUE_IN_NUM_REG_RD ;
605	delete READ_QUEUE_IN_WRITE_RE ;
606	delete READ_QUEUE_IN_NUM_REG_RE ;
607
608	delete READ_QUEUE_OUT_VAL ;
609	delete READ_QUEUE_OUT_ACK ;
610	if(_param->_have_port_context_id )
611	delete READ_QUEUE_OUT_CONTEXT_ID ;
612	if(_param->_have_port_front_end_id )
613	delete READ_QUEUE_OUT_FRONT_END_ID;
614	if(_param->_have_port_ooo_engine_id )
615	delete READ_QUEUE_OUT_OOO_ENGINE_ID;
616	if(_param->_have_port_rob_id )
617	delete READ_QUEUE_OUT_ROB_ID ;
618	delete READ_QUEUE_OUT_OPERATION ;
619	delete READ_QUEUE_OUT_TYPE ;
620	delete READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
621	delete READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
622	delete READ_QUEUE_OUT_HAS_IMMEDIAT;
623	delete READ_QUEUE_OUT_IMMEDIAT ;
624	delete READ_QUEUE_OUT_READ_RA ;
625	delete READ_QUEUE_OUT_NUM_REG_RA ;
626	delete READ_QUEUE_OUT_DATA_RA_VAL ;
627	delete READ_QUEUE_OUT_DATA_RA ;
628	delete READ_QUEUE_OUT_READ_RB ;
629	delete READ_QUEUE_OUT_NUM_REG_RB ;
630	delete READ_QUEUE_OUT_DATA_RB_VAL ;
631	delete READ_QUEUE_OUT_DATA_RB ;
632	delete READ_QUEUE_OUT_READ_RC ;
633	delete READ_QUEUE_OUT_NUM_REG_RC ;
634	delete READ_QUEUE_OUT_DATA_RC_VAL ;
635	delete READ_QUEUE_OUT_DATA_RC ;
636	delete READ_QUEUE_OUT_WRITE_RD ;
637	delete READ_QUEUE_OUT_NUM_REG_RD ;
638	delete READ_QUEUE_OUT_WRITE_RE ;
639	delete READ_QUEUE_OUT_NUM_REG_RE ;
640
641	delete [] GPR_READ_VAL ;
642	delete [] GPR_READ_ACK ;
643	delete [] GPR_READ_NUM_REG ;
644	delete [] GPR_READ_DATA ;
645	delete [] GPR_READ_DATA_VAL;
646	if(_param->_have_port_ooo_engine_id )
647	delete [] GPR_READ_OOO_ENGINE_ID ;
648
649	delete [] SPR_READ_VAL ;
650	delete [] SPR_READ_ACK ;
651	delete [] SPR_READ_NUM_REG ;
652	delete [] SPR_READ_DATA ;
653	delete [] SPR_READ_DATA_VAL;
654	if(_param->_have_port_ooo_engine_id )
655	delete [] SPR_READ_OOO_ENGINE_ID ;
656
657	delete [] GPR_WRITE_VAL ;
658	if(_param->_have_port_ooo_engine_id )
659	delete [] GPR_WRITE_OOO_ENGINE_ID ;
660	delete [] GPR_WRITE_NUM_REG ;
661	delete [] GPR_WRITE_DATA ;
662
663	delete [] SPR_WRITE_VAL ;
664	if(_param->_have_port_ooo_engine_id )
665	delete [] SPR_WRITE_OOO_ENGINE_ID ;
666	delete [] SPR_WRITE_NUM_REG ;
667	delete [] SPR_WRITE_DATA ;
668	#endif
669
670	delete _Read_queue;
671
672	#ifdef STATISTICS
673	delete _parameters_statistics;
674	#endif
675	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: