Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/src/test.cpp @ 88

Last change on this file since 88 was 88, checked in by rosiere, 15 years ago
Almost complete design with Test and test platform
Property svn:keywords set to `Id`
File size: 18.2 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 16
10	#define CYCLE_MAX (1024*NB_ITERATION)
11
12	#include "Behavioural/Core/Multi_Front_end/Front_end/Prediction_unit/Return_Address_Stack/SelfTest/include/test.h"
13	#include "Common/include/Test.h"
14	#include "Behavioural/include/Allocation.h"
15
16	void test (string name,
17	morpheo::behavioural::core::multi_front_end::front_end::prediction_unit::return_address_stack::Parameters * _param)
18	{
19	msg(_("<%s> : Simulation SystemC.\n"),name.c_str());
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	Return_Address_Stack * _Return_Address_Stack = new Return_Address_Stack
36	(name.c_str(),
37	#ifdef STATISTICS
38	_parameters_statistics,
39	#endif
40	_param,
41	_usage);
42
43	#ifdef SYSTEMC
44	/*********************************************************************
45	* Déclarations des signaux
46	*********************************************************************/
47	string rename;
48
49	sc_clock * in_CLOCK = new sc_clock ("clock", 1.0, 0.5);
50	sc_signal<Tcontrol_t> * in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
51
52	ALLOC1_SC_SIGNAL( in_PREDICT_VAL ," in_PREDICT_VAL ",Tcontrol_t,_param->_nb_inst_predict);
53	ALLOC1_SC_SIGNAL(out_PREDICT_ACK ,"out_PREDICT_ACK ",Tcontrol_t,_param->_nb_inst_predict);
54	ALLOC1_SC_SIGNAL( in_PREDICT_CONTEXT_ID ," in_PREDICT_CONTEXT_ID ",Tcontext_t,_param->_nb_inst_predict);
55	ALLOC1_SC_SIGNAL(out_PREDICT_HIT ,"out_PREDICT_HIT ",Tcontrol_t,_param->_nb_inst_predict);
56	ALLOC1_SC_SIGNAL( in_PREDICT_PUSH ," in_PREDICT_PUSH ",Tcontrol_t,_param->_nb_inst_predict);
57	ALLOC1_SC_SIGNAL( in_PREDICT_ADDRESS_PUSH ," in_PREDICT_ADDRESS_PUSH ",Taddress_t,_param->_nb_inst_predict);
58	ALLOC1_SC_SIGNAL(out_PREDICT_ADDRESS_POP ,"out_PREDICT_ADDRESS_POP ",Taddress_t,_param->_nb_inst_predict);
59	ALLOC1_SC_SIGNAL(out_PREDICT_INDEX ,"out_PREDICT_INDEX ",Tptr_t ,_param->_nb_inst_predict);
60	ALLOC1_SC_SIGNAL( in_DECOD_VAL ," in_DECOD_VAL ",Tcontrol_t,_param->_nb_inst_decod );
61	ALLOC1_SC_SIGNAL(out_DECOD_ACK ,"out_DECOD_ACK ",Tcontrol_t,_param->_nb_inst_decod );
62	ALLOC1_SC_SIGNAL( in_DECOD_PUSH ," in_DECOD_PUSH ",Tcontrol_t,_param->_nb_inst_decod );
63	ALLOC1_SC_SIGNAL( in_DECOD_CONTEXT_ID ," in_DECOD_CONTEXT_ID ",Tcontext_t,_param->_nb_inst_decod );
64	ALLOC1_SC_SIGNAL(out_DECOD_HIT ,"out_DECOD_HIT ",Tcontrol_t,_param->_nb_inst_decod );
65	ALLOC1_SC_SIGNAL( in_DECOD_ADDRESS_PUSH ," in_DECOD_ADDRESS_PUSH ",Taddress_t,_param->_nb_inst_decod );
66	ALLOC1_SC_SIGNAL(out_DECOD_ADDRESS_POP ,"out_DECOD_ADDRESS_POP ",Taddress_t,_param->_nb_inst_decod );
67	ALLOC1_SC_SIGNAL(out_DECOD_INDEX ,"out_DECOD_INDEX ",Tptr_t ,_param->_nb_inst_decod );
68	ALLOC1_SC_SIGNAL( in_DECOD_MISS_PREDICTION ," in_DECOD_MISS_PREDICTION ",Tcontrol_t,_param->_nb_inst_decod );
69	ALLOC1_SC_SIGNAL( in_UPDATE_VAL ," in_UPDATE_VAL ",Tcontrol_t,_param->_nb_inst_update );
70	ALLOC1_SC_SIGNAL(out_UPDATE_ACK ,"out_UPDATE_ACK ",Tcontrol_t,_param->_nb_inst_update );
71	ALLOC1_SC_SIGNAL( in_UPDATE_CONTEXT_ID ," in_UPDATE_CONTEXT_ID ",Tcontext_t,_param->_nb_inst_update );
72	ALLOC1_SC_SIGNAL( in_UPDATE_PUSH ," in_UPDATE_PUSH ",Tcontrol_t,_param->_nb_inst_update );
73	ALLOC1_SC_SIGNAL( in_UPDATE_INDEX ," in_UPDATE_INDEX ",Tptr_t ,_param->_nb_inst_update );
74	ALLOC1_SC_SIGNAL( in_UPDATE_ADDRESS ," in_UPDATE_ADDRESS ",Taddress_t,_param->_nb_inst_update );
75	ALLOC1_SC_SIGNAL( in_UPDATE_MISS_PREDICTION," in_UPDATE_MISS_PREDICTION",Tcontrol_t,_param->_nb_inst_update );
76	ALLOC1_SC_SIGNAL( in_UPDATE_PREDICTION_IFETCH," in_UPDATE_PREDICTION_IFETCH",Tcontrol_t,_param->_nb_inst_update );
77
78	/********************************************************
79	* Instanciation
80	********************************************************/
81
82	msg(_("<%s> : Instanciation of _Return_Address_Stack.\n"),name.c_str());
83
84	((_Return_Address_Stack->in_CLOCK)) ((in_CLOCK));
85	((_Return_Address_Stack->in_NRESET)) ((in_NRESET));
86
87	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_PREDICT_VAL ,_param->_nb_inst_predict);
88	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_PREDICT_ACK ,_param->_nb_inst_predict);
89	if (_param->_have_port_context_id)
90	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_PREDICT_CONTEXT_ID ,_param->_nb_inst_predict);
91	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_PREDICT_HIT ,_param->_nb_inst_predict);
92	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_PREDICT_PUSH ,_param->_nb_inst_predict);
93	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_PREDICT_ADDRESS_PUSH ,_param->_nb_inst_predict);
94	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_PREDICT_ADDRESS_POP ,_param->_nb_inst_predict);
95	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_PREDICT_INDEX ,_param->_nb_inst_predict);
96	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_DECOD_VAL ,_param->_nb_inst_decod );
97	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_DECOD_ACK ,_param->_nb_inst_decod );
98	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_DECOD_PUSH ,_param->_nb_inst_decod );
99	if (_param->_have_port_context_id)
100	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_DECOD_CONTEXT_ID ,_param->_nb_inst_decod );
101	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_DECOD_HIT ,_param->_nb_inst_decod );
102	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_DECOD_ADDRESS_PUSH ,_param->_nb_inst_decod );
103	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_DECOD_ADDRESS_POP ,_param->_nb_inst_decod );
104	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_DECOD_INDEX ,_param->_nb_inst_decod );
105	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_DECOD_MISS_PREDICTION ,_param->_nb_inst_decod );
106	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_VAL ,_param->_nb_inst_update );
107	INSTANCE1_SC_SIGNAL(_Return_Address_Stack,out_UPDATE_ACK ,_param->_nb_inst_update );
108	if (_param->_have_port_context_id)
109	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_CONTEXT_ID ,_param->_nb_inst_update );
110	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_PUSH ,_param->_nb_inst_update );
111	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_INDEX ,_param->_nb_inst_update );
112	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_ADDRESS ,_param->_nb_inst_update );
113	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_MISS_PREDICTION,_param->_nb_inst_update );
114	INSTANCE1_SC_SIGNAL(_Return_Address_Stack, in_UPDATE_PREDICTION_IFETCH,_param->_nb_inst_update );
115
116	msg(_("<%s> : Start Simulation ............\n"),name.c_str());
117
118	Time * _time = new Time();
119
120	/********************************************************
121	* Simulation - Begin
122	********************************************************/
123
124	// Initialisation
125
126	const uint32_t seed = 0;
127	//const uint32_t seed = static_cast<uint32_t>(time(NULL));
128
129	srand(seed);
130
131	SC_START(0);
132	LABEL("Initialisation");
133
134	LABEL("Reset");
135	in_NRESET->write(0);
136	SC_START(5);
137	in_NRESET->write(1);
138
139	LABEL("Loop of Test");
140
141	for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
142	{
143	LABEL("Iteration %d",iteration);
144
145	if (1)
146	{
147	uint32_t port = rand()%_param->_nb_inst_predict;
148
149	LABEL("PREDICT - PUSH");
150
151	in_PREDICT_VAL [port]->write(1);
152	in_PREDICT_PUSH [port]->write(1);
153	for (uint32_t i=0; i<_param->_nb_context; i++)
154	for (uint32_t j=0; j<_param->_size_queue[i]; j++)
155	{
156	in_PREDICT_CONTEXT_ID [port]->write(i);
157	in_PREDICT_ADDRESS_PUSH [port]->write(0xdeadbeef+j);
158
159	SC_START(0);
160
161	TEST(Tcontrol_t, out_PREDICT_ACK [port]->read(), 1);
162	TEST(Tptr_t , out_PREDICT_INDEX[port]->read(),(j+1)%_param->_size_queue[i]);
163
164	SC_START(1);
165
166	}
167	in_PREDICT_VAL [port]->write(0);
168
169	SC_START(1);
170
171	in_PREDICT_VAL [port]->write(1);
172	in_PREDICT_PUSH [port]->write(1);
173	for (uint32_t i=0; i<_param->_nb_context; i++)
174	for (uint32_t j=0; j<_param->_size_queue[i]; j++)
175	{
176	in_PREDICT_CONTEXT_ID [port]->write(i);
177	in_PREDICT_ADDRESS_PUSH [port]->write(0x21071981+j);
178
179	SC_START(0);
180
181	TEST(Tcontrol_t, out_PREDICT_ACK [port]->read(), 1);
182	TEST(Tptr_t , out_PREDICT_INDEX [port]->read(),(j+1)%_param->_size_queue[i]);
183	TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port]->read(),0xdeadbeef+j);
184
185	SC_START(1);
186	}
187	in_PREDICT_VAL [port]->write(0);
188
189	LABEL("PREDICT - POP");
190
191	in_PREDICT_VAL [port]->write(1);
192	in_PREDICT_PUSH [port]->write(0);
193	for (uint32_t i=0; i<_param->_nb_context; i++)
194	for (uint32_t j=0; j< _param->_size_queue[i]; j++)
195	{
196	in_PREDICT_CONTEXT_ID [port]->write(i);
197	in_PREDICT_ADDRESS_PUSH [port]->write(0xbabedead);
198
199	SC_START(0);
200
201	TEST(Tcontrol_t, out_PREDICT_ACK [port]->read(), 1);
202	TEST(Tcontrol_t, out_PREDICT_HIT [port]->read(), 1);
203	uint32_t k=(_param->_size_queue[i]-j)%_param->_size_queue[i];
204	TEST(Tptr_t , out_PREDICT_INDEX [port]->read(), k);
205	TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port]->read(),(0x21071981+((k==0)?(_param->_size_queue[i]-1):(k-1))));
206
207	SC_START(1);
208	}
209	in_PREDICT_VAL [port]->write(0);
210	}
211
212	// Now, the stack is empty
213
214	if (1)
215	{
216	uint32_t port1 = rand()%_param->_nb_inst_decod;
217	uint32_t port2 = rand()%_param->_nb_inst_predict;
218
219	LABEL("DECOD - without predict");
220
221	LABEL("DECOD - PUSH");
222
223	in_DECOD_VAL [port1]->write(1);
224	in_DECOD_PUSH [port1]->write(1);
225	in_DECOD_MISS_PREDICTION [port1]->write(0);
226
227	for (uint32_t i=0; i<_param->_nb_context; i++)
228	for (uint32_t j=0; j<_param->_size_queue[i]; j++)
229	{
230	in_DECOD_CONTEXT_ID [port1]->write(i);
231	in_DECOD_ADDRESS_PUSH [port1]->write(0xbeefcaca+j);
232
233	SC_START(0);
234
235	TEST(Tcontrol_t, out_DECOD_ACK [port1]->read(), 1);
236	TEST(Tptr_t , out_DECOD_INDEX[port1]->read(),(j+1)%_param->_size_queue[i]);
237
238	SC_START(1);
239
240	}
241	in_DECOD_VAL [port1]->write(0);
242
243	SC_START(1);
244
245	in_DECOD_VAL [port1]->write(1);
246	in_DECOD_PUSH [port1]->write(1);
247	for (uint32_t i=0; i<_param->_nb_context; i++)
248	for (uint32_t j=0; j<_param->_size_queue[i]; j++)
249	{
250	in_DECOD_CONTEXT_ID [port1]->write(i);
251	in_DECOD_ADDRESS_PUSH [port1]->write(0x21071981+j);
252
253	SC_START(0);
254
255	TEST(Tcontrol_t, out_DECOD_ACK [port1]->read(), 1);
256	TEST(Tptr_t , out_DECOD_INDEX [port1]->read(),(j+1)%_param->_size_queue[i]);
257	TEST(Taddress_t, out_DECOD_ADDRESS_POP[port1]->read(),0xbeefcaca+j);
258
259	SC_START(1);
260	}
261	in_DECOD_VAL [port1]->write(0);
262
263	LABEL("DECOD - POP");
264
265	in_DECOD_VAL [port1]->write(1);
266	in_DECOD_PUSH [port1]->write(0);
267	for (uint32_t i=0; i<_param->_nb_context; i++)
268	for (uint32_t j=0; j< _param->_size_queue[i]; j++)
269	{
270	in_DECOD_CONTEXT_ID [port1]->write(i);
271	in_DECOD_ADDRESS_PUSH [port1]->write(0xbabedead);
272
273	SC_START(0);
274
275	TEST(Tcontrol_t, out_DECOD_ACK [port1]->read(), 1);
276	TEST(Tcontrol_t, out_DECOD_HIT [port1]->read(), 1);
277	uint32_t k=(_param->_size_queue[i]-j)%_param->_size_queue[i];
278	TEST(Tptr_t , out_DECOD_INDEX [port1]->read(), k);
279	TEST(Taddress_t, out_DECOD_ADDRESS_POP[port1]->read(),(0x21071981+((k==0)?(_param->_size_queue[i]-1):(k-1))));
280
281	SC_START(1);
282	}
283	in_DECOD_VAL [port1]->write(0);
284
285	LABEL("DECOD - with predict");
286
287	LABEL("DECOD - PUSH (size_queue/2)");
288
289	in_DECOD_VAL [port1]->write(1);
290	in_DECOD_PUSH [port1]->write(1);
291	in_DECOD_MISS_PREDICTION [port1]->write(1);
292
293	for (uint32_t i=0; i<_param->_nb_context; i++)
294	for (uint32_t j=0; j<_param->_size_queue[i]/2;j++)
295	{
296	in_DECOD_CONTEXT_ID [port1]->write(i);
297	in_DECOD_ADDRESS_PUSH [port1]->write(0x01234567+j);
298
299	SC_START(0);
300
301	TEST(Tcontrol_t, out_DECOD_ACK [port1]->read(), 1);
302	TEST(Tptr_t , out_DECOD_INDEX[port1]->read(),(j+1)%_param->_size_queue[i]);
303
304	SC_START(1);
305
306	}
307	in_DECOD_VAL [port1]->write(0);
308
309	LABEL("PREDICT - PUSH (size_queue/2)");
310
311	in_PREDICT_VAL [port2]->write(1);
312	in_PREDICT_PUSH [port2]->write(1);
313
314	for (uint32_t i=0; i<_param->_nb_context; i++)
315	for (uint32_t j=0; j<_param->_size_queue[i]/2;j++)
316	{
317	in_PREDICT_CONTEXT_ID [port2]->write(i);
318	in_PREDICT_ADDRESS_PUSH [port2]->write((0x89abcdef+j)+(_param->_size_queue[i]/2));
319
320	SC_START(0);
321
322	TEST(Tcontrol_t, out_PREDICT_ACK [port2]->read(), 1);
323	TEST(Tptr_t , out_PREDICT_INDEX[port2]->read(),(j+1+(_param->_size_queue[i]/2))%_param->_size_queue[i]);
324
325	SC_START(1);
326	}
327
328	in_PREDICT_VAL [port2]->write(0);
329
330	LABEL("PREDICT - POP (size_queue/2)");
331
332	in_PREDICT_VAL [port2]->write(1);
333	in_PREDICT_PUSH [port2]->write(0);
334	for (uint32_t i=0; i<_param->_nb_context; i++)
335	{
336	for (uint32_t j=0; j< _param->_size_queue[i]/2; j++)
337	{
338	in_PREDICT_CONTEXT_ID [port2]->write(i);
339	in_PREDICT_ADDRESS_PUSH [port2]->write(0xbabedead);
340
341	SC_START(0);
342
343	TEST(Tcontrol_t, out_PREDICT_ACK [port2]->read(), 1);
344	TEST(Tcontrol_t, out_PREDICT_HIT [port2]->read(), 1);
345	uint32_t k= (_param->_size_queue[i]-j)%_param->_size_queue[i];
346	TEST(Tptr_t , out_PREDICT_INDEX [port2]->read(), k);
347
348	Taddress_t res = (0x89abcdef+((k==0)?(_param->_size_queue[i]-1):(k-1)));
349	LABEL("k : %d",k);
350	LABEL("res : %x",res);
351	LABEL("@_pop : %x",out_PREDICT_ADDRESS_POP[port2]->read());
352
353	TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port2]->read(),res);
354
355	SC_START(1);
356	}
357
358	for (uint32_t j=0; j< _param->_size_queue[i]/2; j++)
359	{
360	in_PREDICT_CONTEXT_ID [port2]->write(i);
361	in_PREDICT_ADDRESS_PUSH [port2]->write(0xbabedead);
362
363	SC_START(0);
364
365	TEST(Tcontrol_t, out_PREDICT_ACK [port2]->read(), 1);
366	TEST(Tcontrol_t, out_PREDICT_HIT [port2]->read(), 1);
367	uint32_t k=(_param->_size_queue[i]/2-j)%_param->_size_queue[i];
368	TEST(Tptr_t , out_PREDICT_INDEX [port2]->read(), k);
369
370	Taddress_t res = (0x01234567+((k==0)?(_param->_size_queue[i]/2-1):(k-1)));
371
372	LABEL("k : %d",k);
373	LABEL("res : %x",res);
374	LABEL("@_pop : %x",out_PREDICT_ADDRESS_POP[port2]->read());
375
376	TEST(Taddress_t, out_PREDICT_ADDRESS_POP[port2]->read(),res);
377
378	SC_START(1);
379	}
380	}
381
382	in_PREDICT_VAL [port2]->write(0);
383
384	in_DECOD_VAL [port1]->write(1);
385	in_DECOD_PUSH [port1]->write(0);
386	in_DECOD_MISS_PREDICTION [port1]->write(0);
387
388	for (uint32_t i=0; i<_param->_nb_context; i++)
389	{
390	for (uint32_t j=0; j< _param->_size_queue[i]/2; j++)
391	{
392	in_DECOD_CONTEXT_ID [port1]->write(i);
393	in_DECOD_ADDRESS_PUSH [port1]->write(0xbabedead);
394
395	SC_START(0);
396
397	TEST(Tcontrol_t, out_DECOD_ACK [port1]->read(), 1);
398	TEST(Tcontrol_t, out_DECOD_HIT [port1]->read(), 1);
399	uint32_t k=(_param->_size_queue[i]/2-j)%_param->_size_queue[i];
400	TEST(Tptr_t , out_DECOD_INDEX [port1]->read(), k);
401
402	Taddress_t res = (0x01234567+((k==0)?(_param->_size_queue[i]/2-1):(k-1)));
403
404	LABEL("k : %d",k);
405	LABEL("res : %x",res);
406	LABEL("@_pop : %x",out_DECOD_ADDRESS_POP[port1]->read());
407
408	TEST(Taddress_t, out_DECOD_ADDRESS_POP[port1]->read(),res);
409
410	SC_START(1);
411	}
412	}
413
414	in_DECOD_VAL [port1]->write(0);
415	}
416	}
417
418	/********************************************************
419	* Simulation - End
420	********************************************************/
421
422	TEST_OK ("End of Simulation");
423	delete _time;
424
425	msg(_("<%s> : ............ Stop Simulation\n"),name.c_str());
426
427	delete in_CLOCK;
428	delete in_NRESET;
429
430	DELETE1_SC_SIGNAL( in_PREDICT_VAL ,_param->_nb_inst_predict);
431	DELETE1_SC_SIGNAL(out_PREDICT_ACK ,_param->_nb_inst_predict);
432	DELETE1_SC_SIGNAL( in_PREDICT_CONTEXT_ID ,_param->_nb_inst_predict);
433	DELETE1_SC_SIGNAL(out_PREDICT_HIT ,_param->_nb_inst_predict);
434	DELETE1_SC_SIGNAL( in_PREDICT_PUSH ,_param->_nb_inst_predict);
435	DELETE1_SC_SIGNAL( in_PREDICT_ADDRESS_PUSH ,_param->_nb_inst_predict);
436	DELETE1_SC_SIGNAL(out_PREDICT_ADDRESS_POP ,_param->_nb_inst_predict);
437	DELETE1_SC_SIGNAL(out_PREDICT_INDEX ,_param->_nb_inst_predict);
438
439	DELETE1_SC_SIGNAL( in_DECOD_VAL ,_param->_nb_inst_decod);
440	DELETE1_SC_SIGNAL(out_DECOD_ACK ,_param->_nb_inst_decod);
441	DELETE1_SC_SIGNAL( in_DECOD_CONTEXT_ID ,_param->_nb_inst_decod);
442	DELETE1_SC_SIGNAL(out_DECOD_HIT ,_param->_nb_inst_decod);
443	DELETE1_SC_SIGNAL( in_DECOD_PUSH ,_param->_nb_inst_decod);
444	DELETE1_SC_SIGNAL( in_DECOD_ADDRESS_PUSH ,_param->_nb_inst_decod);
445	DELETE1_SC_SIGNAL(out_DECOD_ADDRESS_POP ,_param->_nb_inst_decod);
446	DELETE1_SC_SIGNAL(out_DECOD_INDEX ,_param->_nb_inst_decod);
447	DELETE1_SC_SIGNAL( in_DECOD_MISS_PREDICTION ,_param->_nb_inst_decod);
448
449	DELETE1_SC_SIGNAL( in_UPDATE_VAL ,_param->_nb_inst_update);
450	DELETE1_SC_SIGNAL(out_UPDATE_ACK ,_param->_nb_inst_update);
451	DELETE1_SC_SIGNAL( in_UPDATE_CONTEXT_ID ,_param->_nb_inst_update);
452	DELETE1_SC_SIGNAL( in_UPDATE_PUSH ,_param->_nb_inst_update);
453	DELETE1_SC_SIGNAL( in_UPDATE_ADDRESS ,_param->_nb_inst_update);
454	DELETE1_SC_SIGNAL( in_UPDATE_INDEX ,_param->_nb_inst_update);
455	DELETE1_SC_SIGNAL( in_UPDATE_MISS_PREDICTION ,_param->_nb_inst_update);
456	DELETE1_SC_SIGNAL( in_UPDATE_PREDICTION_IFETCH,_param->_nb_inst_update);
457
458	#endif
459
460	delete _Return_Address_Stack;
461	#ifdef STATISTICS
462	delete _parameters_statistics;
463	#endif
464	}

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

Download in other formats: