Context Navigation

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

Last change on this file since 95 was 95, checked in by rosiere, 15 years ago
1) Update Prediction Table - New architecture (systemC) done (and tested) -> need change interface in top level 2) Change documentation on VHDL generation 3) Change VHDL constant (case std_logic and std_logic_vector)
Property svn:keywords set to `Id`
File size: 18.5 KB

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

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

Download in other formats: