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 @ 82

Last change on this file since 82 was 82, checked in by rosiere, 16 years ago
support locale (now must "just" translate) update all component with new test format update all component with usage New component : decod queue and prediction_unit
Property svn:keywords set to `Id`
File size: 35.2 KB

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

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

Download in other formats: