Context Navigation

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

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

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

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

Download in other formats: