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

Last change on this file since 88 was 88, checked in by rosiere, 16 years ago
Almost complete design with Test and test platform
Property svn:keywords set to `Id`
File size: 35.6 KB

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

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

Download in other formats: