Context Navigation

test.cpp @ 98

Last change on this file since 98 was 98, checked in by rosiere, 15 years ago
1) Fix bug (read unit, RAT -> write in R0, SPR desallocation ...) 2) Change VHDL Execute_queue -> use Generic/Queue? 3) Complete document on VHDL generation 4) Add soc test
Property svn:keywords set to `Id`
File size: 35.8 KB

Line
1	/*
2	* $Id: test.cpp 98 2008-12-31 10:18:08Z 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	_gpr_val [0][j] = 0;
373	_gpr [0][j] = 0;
374	_spr_val [0][j] = 0;
375	_spr [0][j] = 0;
376
377	for (uint32_t i=1; i<_param->_nb_general_register; i++)
378	{
379	_gpr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
380	_gpr [i][j] = rand()%(1<<_param->_size_general_data);
381	}
382	for (uint32_t i=1; i<_param->_nb_special_register; i++)
383	{
384	_spr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
385	_spr [i][j] = rand()%(1<<_param->_size_special_data);
386	}
387	}
388
389
390	// End initialisation .......
391
392	uint32_t request_in = 0;
393	uint32_t request_out = 0;
394
395	while (request_out < nb_request)
396	{
397	if ((request_in < nb_request) and
398	((rand()%100) < percent_transaction_queue_in))
399	{
400	READ_QUEUE_IN_VAL ->write(1);
401	if(_param->_have_port_ooo_engine_id)
402	READ_QUEUE_IN_OOO_ENGINE_ID ->write(_ooo_engine_id [request_in]);
403	if(_param->_have_port_context_id )
404	READ_QUEUE_IN_CONTEXT_ID ->write((2*_ooo_engine_id [request_in])%_param->_nb_context );
405	if(_param->_have_port_front_end_id )
406	READ_QUEUE_IN_FRONT_END_ID ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
407	if(_param->_have_port_rob_ptr )
408	READ_QUEUE_IN_ROB_ID ->write(request_in);
409	READ_QUEUE_IN_OPERATION ->write(0);
410	READ_QUEUE_IN_TYPE ->write(0);
411	READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE->write(0);
412	if (_param->_have_port_load_queue_ptr)
413	READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ->write(0);
414	READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
415	READ_QUEUE_IN_IMMEDIAT ->write(0);
416	READ_QUEUE_IN_READ_RA ->write(_read_ra [request_in]);
417	READ_QUEUE_IN_NUM_REG_RA ->write(_num_reg_ra [request_in]);
418	READ_QUEUE_IN_READ_RB ->write(_read_rb [request_in]);
419	READ_QUEUE_IN_NUM_REG_RB ->write(_num_reg_rb [request_in]);
420	READ_QUEUE_IN_READ_RC ->write(_read_rc [request_in]);
421	READ_QUEUE_IN_NUM_REG_RC ->write(_num_reg_rc [request_in]);
422	READ_QUEUE_IN_WRITE_RD ->write(0);
423	READ_QUEUE_IN_NUM_REG_RD ->write(0);
424	READ_QUEUE_IN_WRITE_RE ->write(0);
425	READ_QUEUE_IN_NUM_REG_RE ->write(0);
426	}
427	else
428	{
429	READ_QUEUE_IN_VAL ->write(0);
430	}
431
432	READ_QUEUE_OUT_ACK ->write((rand()%100) < percent_transaction_queue_out);
433
434	// RegisterFile access
435	for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
436	{
437	GPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
438	if (GPR_READ_VAL [i]->read())
439	{
440	Tgeneral_address_t num_reg = GPR_READ_NUM_REG [i]->read();
441	Tcontext_t ooo_engine;
442	if(_param->_have_port_ooo_engine_id)
443	ooo_engine = GPR_READ_OOO_ENGINE_ID [i]->read();
444	else
445	ooo_engine = 0;
446
447	GPR_READ_DATA [i]->write(_gpr [num_reg][ooo_engine]);
448	GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][ooo_engine]);
449	}
450	}
451	for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
452	{
453	SPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
454
455	if (SPR_READ_VAL [i]->read())
456	{
457	Tspecial_address_t num_reg = SPR_READ_NUM_REG [i]->read();
458	Tcontext_t ooo_engine;
459	if(_param->_have_port_ooo_engine_id)
460	ooo_engine = SPR_READ_OOO_ENGINE_ID [i]->read();
461	else
462	ooo_engine = 0;
463
464	SPR_READ_DATA [i]->write(_spr [num_reg][ooo_engine]);
465	SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][ooo_engine]);
466	}
467	}
468
469	// BYPASS
470	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
471	{
472	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
473	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
474	Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
475	Tgeneral_data_t data = (num_reg!=0)?(rand()%(1<<_param->_size_general_data)):0;
476
477	GPR_WRITE_VAL [i]->write(val);
478	if(_param->_have_port_ooo_engine_id)
479	GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
480	GPR_WRITE_NUM_REG [i]->write(num_reg);
481	GPR_WRITE_DATA [i]->write(data);
482
483	if (val)
484	{
485	_gpr [num_reg][ooo_engine] = data;
486	_gpr_val [num_reg][ooo_engine] = 1;
487	}
488	}
489	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
490	{
491	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
492	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
493	Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
494	Tspecial_data_t data = rand()%(1<<_param->_size_special_data);
495
496	SPR_WRITE_VAL [i]->write(val);
497	if(_param->_have_port_ooo_engine_id)
498	SPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
499	SPR_WRITE_NUM_REG [i]->write(num_reg);
500	SPR_WRITE_DATA [i]->write(data);
501
502	if (val)
503	{
504	_spr [num_reg][ooo_engine] = data;
505	_spr_val [num_reg][ooo_engine] = 1;
506	}
507	}
508
509	SC_START(0);
510
511	LABEL("Test READ_QUEUE_IN : %d,%d",READ_QUEUE_IN_VAL->read(),READ_QUEUE_IN_ACK->read());
512	if ((READ_QUEUE_IN_VAL->read() == 1) and
513	(READ_QUEUE_IN_ACK->read() == 1))
514	{
515	LABEL("Accepted READ_QUEUE_IN [%d]",request_in);
516	request_in ++;
517	}
518	LABEL("Test READ_QUEUE_OUT : %d,%d",READ_QUEUE_OUT_VAL->read(),READ_QUEUE_OUT_ACK->read());
519	if ((READ_QUEUE_OUT_VAL->read() == 1) and
520	(READ_QUEUE_OUT_ACK->read() == 1))
521	{
522	Tpacket_t rob_id;
523	if(_param->_have_port_rob_ptr )
524	rob_id = READ_QUEUE_OUT_ROB_ID->read();
525	else
526	rob_id = 0;
527	Tcontext_t ctxt = _ooo_engine_id [rob_id];
528	LABEL("Accepted READ_QUEUE_OUT [%d]",rob_id);
529
530	TEST(uint32_t , rob_id ,request_out);
531
532	request_out ++;
533
534	if(_param->_have_port_ooo_engine_id)
535	TEST(Tcontext_t ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
536	if(_param->_have_port_context_id )
537	TEST(Tcontext_t ,READ_QUEUE_OUT_CONTEXT_ID ->read(),(2*ctxt)%_param->_nb_context );
538	if(_param->_have_port_front_end_id )
539	TEST(Tcontext_t ,READ_QUEUE_OUT_FRONT_END_ID ->read(),(3*ctxt)%_param->_nb_front_end);
540
541	// TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RA ->read(),_read_ra [rob_id]);
542	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RA ->read(),_num_reg_ra [rob_id]);
543	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RA_VAL->read(),not _read_ra [rob_id] or _gpr_val [_num_reg_ra[rob_id]][ctxt] or (_num_reg_ra[rob_id] == 0));
544	if (_read_ra [rob_id] and
545	READ_QUEUE_OUT_DATA_RA_VAL->read())
546	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RA ->read(),_gpr [_num_reg_ra[rob_id]][ctxt]);
547	// TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RB ->read(),_read_rb [rob_id]);
548	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RB ->read(),_num_reg_rb [rob_id]);
549	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RB_VAL->read(),not _read_rb [rob_id] or _gpr_val [_num_reg_rb[rob_id]][ctxt] or (_num_reg_rb[rob_id] == 0));
550	if (_read_rb [rob_id] and
551	READ_QUEUE_OUT_DATA_RB_VAL->read())
552	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RB ->read(),_gpr [_num_reg_rb[rob_id]][ctxt]);
553	// TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RC ->read(),_read_rc [rob_id]);
554	TEST(Tspecial_address_t,READ_QUEUE_OUT_NUM_REG_RC ->read(),_num_reg_rc [rob_id]);
555	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RC_VAL->read(),not _read_rc [rob_id] or _spr_val [_num_reg_rc[rob_id]][ctxt]);
556	if (_read_rc [rob_id] and
557	READ_QUEUE_OUT_DATA_RC_VAL->read())
558	TEST(Tspecial_data_t ,READ_QUEUE_OUT_DATA_RC ->read(),_spr [_num_reg_rc[rob_id]][ctxt]);
559	}
560	SC_START(1);
561	}
562	}
563
564	/********************************************************
565	* Simulation - End
566	********************************************************/
567
568	TEST_OK ("End of Simulation");
569	delete _time;
570
571	cout << "<" << name << "> ............ Stop Simulation" << endl;
572
573	delete CLOCK;
574	delete NRESET;
575
576	delete READ_QUEUE_IN_VAL ;
577	delete READ_QUEUE_IN_ACK ;
578	if(_param->_have_port_context_id )
579	delete READ_QUEUE_IN_CONTEXT_ID ;
580	if(_param->_have_port_front_end_id )
581	delete READ_QUEUE_IN_FRONT_END_ID;
582	if(_param->_have_port_ooo_engine_id )
583	delete READ_QUEUE_IN_OOO_ENGINE_ID;
584	if(_param->_have_port_rob_ptr )
585	delete READ_QUEUE_IN_ROB_ID ;
586	delete READ_QUEUE_IN_OPERATION ;
587	delete READ_QUEUE_IN_TYPE ;
588	delete READ_QUEUE_IN_STORE_QUEUE_PTR_WRITE;
589	if (_param->_have_port_load_queue_ptr)
590	delete READ_QUEUE_IN_LOAD_QUEUE_PTR_WRITE ;
591	delete READ_QUEUE_IN_HAS_IMMEDIAT ;
592	delete READ_QUEUE_IN_IMMEDIAT ;
593	delete READ_QUEUE_IN_READ_RA ;
594	delete READ_QUEUE_IN_NUM_REG_RA ;
595	delete READ_QUEUE_IN_READ_RB ;
596	delete READ_QUEUE_IN_NUM_REG_RB ;
597	delete READ_QUEUE_IN_READ_RC ;
598	delete READ_QUEUE_IN_NUM_REG_RC ;
599	delete READ_QUEUE_IN_WRITE_RD ;
600	delete READ_QUEUE_IN_NUM_REG_RD ;
601	delete READ_QUEUE_IN_WRITE_RE ;
602	delete READ_QUEUE_IN_NUM_REG_RE ;
603
604	delete READ_QUEUE_OUT_VAL ;
605	delete READ_QUEUE_OUT_ACK ;
606	if(_param->_have_port_context_id )
607	delete READ_QUEUE_OUT_CONTEXT_ID ;
608	if(_param->_have_port_front_end_id )
609	delete READ_QUEUE_OUT_FRONT_END_ID;
610	if(_param->_have_port_ooo_engine_id )
611	delete READ_QUEUE_OUT_OOO_ENGINE_ID;
612	if(_param->_have_port_rob_ptr )
613	delete READ_QUEUE_OUT_ROB_ID ;
614	delete READ_QUEUE_OUT_OPERATION ;
615	delete READ_QUEUE_OUT_TYPE ;
616	delete READ_QUEUE_OUT_STORE_QUEUE_PTR_WRITE;
617	if (_param->_have_port_load_queue_ptr)
618	delete READ_QUEUE_OUT_LOAD_QUEUE_PTR_WRITE ;
619	delete READ_QUEUE_OUT_HAS_IMMEDIAT;
620	delete READ_QUEUE_OUT_IMMEDIAT ;
621	delete READ_QUEUE_OUT_READ_RA ;
622	delete READ_QUEUE_OUT_NUM_REG_RA ;
623	delete READ_QUEUE_OUT_DATA_RA_VAL ;
624	delete READ_QUEUE_OUT_DATA_RA ;
625	delete READ_QUEUE_OUT_READ_RB ;
626	delete READ_QUEUE_OUT_NUM_REG_RB ;
627	delete READ_QUEUE_OUT_DATA_RB_VAL ;
628	delete READ_QUEUE_OUT_DATA_RB ;
629	delete READ_QUEUE_OUT_READ_RC ;
630	delete READ_QUEUE_OUT_NUM_REG_RC ;
631	delete READ_QUEUE_OUT_DATA_RC_VAL ;
632	delete READ_QUEUE_OUT_DATA_RC ;
633	delete READ_QUEUE_OUT_WRITE_RD ;
634	delete READ_QUEUE_OUT_NUM_REG_RD ;
635	delete READ_QUEUE_OUT_WRITE_RE ;
636	delete READ_QUEUE_OUT_NUM_REG_RE ;
637
638	delete [] GPR_READ_VAL ;
639	delete [] GPR_READ_ACK ;
640	delete [] GPR_READ_NUM_REG ;
641	delete [] GPR_READ_DATA ;
642	delete [] GPR_READ_DATA_VAL;
643	if(_param->_have_port_ooo_engine_id )
644	delete [] GPR_READ_OOO_ENGINE_ID ;
645
646	delete [] SPR_READ_VAL ;
647	delete [] SPR_READ_ACK ;
648	delete [] SPR_READ_NUM_REG ;
649	delete [] SPR_READ_DATA ;
650	delete [] SPR_READ_DATA_VAL;
651	if(_param->_have_port_ooo_engine_id )
652	delete [] SPR_READ_OOO_ENGINE_ID ;
653
654	delete [] GPR_WRITE_VAL ;
655	if(_param->_have_port_ooo_engine_id )
656	delete [] GPR_WRITE_OOO_ENGINE_ID ;
657	delete [] GPR_WRITE_NUM_REG ;
658	delete [] GPR_WRITE_DATA ;
659
660	delete [] SPR_WRITE_VAL ;
661	if(_param->_have_port_ooo_engine_id )
662	delete [] SPR_WRITE_OOO_ENGINE_ID ;
663	delete [] SPR_WRITE_NUM_REG ;
664	delete [] SPR_WRITE_DATA ;
665	#endif
666
667	delete _Read_queue;
668
669	#ifdef STATISTICS
670	delete _parameters_statistics;
671	#endif
672	}

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

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

Download in other formats: