Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/src/test.cpp @ 81

Last change on this file since 81 was 81, checked in by rosiere, 16 years ago
Finish Environment (and test) Continue predictor_unit Add external tools svn keyword "Id" set
Property svn:keywords set to `Id`
File size: 49.7 KB

Line
1	/*
2	* $Id: test.cpp 81 2008-04-15 18:40:01Z rosiere $
3	*
4	* [ Description ]
5	*
6	* Test
7	*/
8
9	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/SelfTest/include/test.h"
10	#include "Common/include/Test.h"
11
12	#define NB_ITERATION 128
13	#define CYCLE_MAX (128*NB_ITERATION)
14
15	#define LABEL(str) \
16	{ \
17	cout << "{"+toString(static_cast<uint32_t>(sc_simulation_time()))+"} " << str << endl; \
18	} while(0)
19
20	static uint32_t cycle = 0;
21
22	#define SC_START(cycle_offset) \
23	do \
24	{ \
25	/cout << "SC_START (begin)" << endl;/ \
26	\
27	uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time()); \
28	if (cycle_current != cycle) \
29	{ \
30	cycle = cycle_current; \
31	cout << "##########[ cycle "<< cycle << " ]" << endl; \
32	} \
33	\
34	if (cycle_current > CYCLE_MAX) \
35	{ \
36	TEST_KO("Maximal cycles Reached"); \
37	} \
38	sc_start(cycle_offset); \
39	/cout << "SC_START (end )" << endl;/ \
40	} while(0)
41
42	void test (string name,
43	morpheo::behavioural::core::multi_execute_loop::execute_loop::register_unit::register_unit_glue::Parameters * _param)
44	{
45	cout << "<" << name << "> : Simulation SystemC" << endl;
46
47	#ifdef STATISTICS
48	morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
49	#endif
50
51	Register_unit_Glue * _Register_unit_Glue = new Register_unit_Glue (name.c_str(),
52	#ifdef STATISTICS
53	_parameters_statistics,
54	#endif
55	_param);
56
57	#ifdef SYSTEMC
58	/*********************************************************************
59	* Déclarations des signaux
60	*********************************************************************/
61	sc_clock * in_CLOCK;
62	sc_signal<Tcontrol_t> * in_NRESET;
63	sc_signal<Tcontrol_t> * out_CONST_0;
64	sc_signal<Tcontrol_t> * out_CONST_1;
65
66	sc_signal<Tcontrol_t > ** in_GPR_READ_VAL ;
67	sc_signal<Tcontrol_t > ** out_GPR_READ_ACK ;
68	sc_signal<Tcontext_t > ** in_GPR_READ_OOO_ENGINE_ID ;
69	sc_signal<Tgeneral_data_t > ** out_GPR_READ_DATA ;
70	sc_signal<Tcontrol_t > ** out_GPR_READ_DATA_VAL ;
71	sc_signal<Tcontrol_t > *** out_GPR_READ_REGISTERFILE_VAL ;
72	sc_signal<Tcontrol_t > *** in_GPR_READ_REGISTERFILE_ACK ;
73	sc_signal<Tgeneral_data_t > *** in_GPR_READ_REGISTERFILE_DATA;
74	sc_signal<Tcontrol_t > *** out_GPR_READ_STATUS_VAL ;
75	sc_signal<Tcontrol_t > *** in_GPR_READ_STATUS_ACK ;
76	sc_signal<Tcontrol_t > *** in_GPR_READ_STATUS_DATA_VAL ;
77
78	sc_signal<Tcontrol_t > ** in_SPR_READ_VAL ;
79	sc_signal<Tcontrol_t > ** out_SPR_READ_ACK ;
80	sc_signal<Tcontext_t > ** in_SPR_READ_OOO_ENGINE_ID ;
81	sc_signal<Tspecial_data_t > ** out_SPR_READ_DATA ;
82	sc_signal<Tcontrol_t > ** out_SPR_READ_DATA_VAL ;
83	sc_signal<Tcontrol_t > *** out_SPR_READ_REGISTERFILE_VAL ;
84	sc_signal<Tcontrol_t > *** in_SPR_READ_REGISTERFILE_ACK ;
85	sc_signal<Tspecial_data_t > *** in_SPR_READ_REGISTERFILE_DATA;
86	sc_signal<Tcontrol_t > *** out_SPR_READ_STATUS_VAL ;
87	sc_signal<Tcontrol_t > *** in_SPR_READ_STATUS_ACK ;
88	sc_signal<Tcontrol_t > *** in_SPR_READ_STATUS_DATA_VAL ;
89
90	sc_signal<Tcontrol_t > ** in_GPR_WRITE_VAL ;
91	sc_signal<Tcontrol_t > ** out_GPR_WRITE_ACK ;
92	sc_signal<Tcontext_t > ** in_GPR_WRITE_OOO_ENGINE_ID ;
93	sc_signal<Tcontrol_t > *** out_GPR_WRITE_REGISTERFILE_VAL;
94	sc_signal<Tcontrol_t > *** in_GPR_WRITE_REGISTERFILE_ACK;
95	sc_signal<Tcontrol_t > *** out_GPR_WRITE_STATUS_VAL ;
96	sc_signal<Tcontrol_t > *** in_GPR_WRITE_STATUS_ACK ;
97
98	sc_signal<Tcontrol_t > ** in_SPR_WRITE_VAL ;
99	sc_signal<Tcontrol_t > ** out_SPR_WRITE_ACK ;
100	sc_signal<Tcontext_t > ** in_SPR_WRITE_OOO_ENGINE_ID ;
101	sc_signal<Tcontrol_t > *** out_SPR_WRITE_REGISTERFILE_VAL;
102	sc_signal<Tcontrol_t > *** in_SPR_WRITE_REGISTERFILE_ACK;
103	sc_signal<Tcontrol_t > *** out_SPR_WRITE_STATUS_VAL ;
104	sc_signal<Tcontrol_t > *** in_SPR_WRITE_STATUS_ACK ;
105
106	sc_signal<Tcontrol_t > *** in_INSERT_ROB_VAL ;
107	sc_signal<Tcontrol_t > *** out_INSERT_ROB_ACK ;
108	sc_signal<Tcontrol_t > *** in_INSERT_ROB_RD_USE ;
109	sc_signal<Tcontrol_t > *** in_INSERT_ROB_RE_USE ;
110	sc_signal<Tcontrol_t > *** out_INSERT_ROB_GPR_STATUS_VAL ;
111	sc_signal<Tcontrol_t > *** in_INSERT_ROB_GPR_STATUS_ACK ;
112	sc_signal<Tcontrol_t > *** out_INSERT_ROB_SPR_STATUS_VAL ;
113	sc_signal<Tcontrol_t > *** in_INSERT_ROB_SPR_STATUS_ACK ;
114
115	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_VAL ;
116	sc_signal<Tcontrol_t > *** out_RETIRE_ROB_ACK ;
117	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_RD_OLD_USE ;
118	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_RD_NEW_USE ;
119	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_RE_OLD_USE ;
120	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_RE_NEW_USE ;
121	sc_signal<Tcontrol_t > *** out_RETIRE_ROB_GPR_STATUS_NEW_VAL ;
122	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_GPR_STATUS_NEW_ACK ;
123	sc_signal<Tcontrol_t > *** out_RETIRE_ROB_GPR_STATUS_OLD_VAL ;
124	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_GPR_STATUS_OLD_ACK ;
125	sc_signal<Tcontrol_t > *** out_RETIRE_ROB_SPR_STATUS_NEW_VAL ;
126	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_SPR_STATUS_NEW_ACK ;
127	sc_signal<Tcontrol_t > *** out_RETIRE_ROB_SPR_STATUS_OLD_VAL ;
128	sc_signal<Tcontrol_t > *** in_RETIRE_ROB_SPR_STATUS_OLD_ACK ;
129
130	string rename;
131
132	in_CLOCK = new sc_clock ("clock", 1.0, 0.5);
133	in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
134	out_CONST_0 = new sc_signal<Tcontrol_t> ("CONST_0");
135	out_CONST_1 = new sc_signal<Tcontrol_t> ("CONST_1");
136
137	// ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
138	in_GPR_READ_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
139	out_GPR_READ_ACK = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
140	in_GPR_READ_OOO_ENGINE_ID = new sc_signal<Tcontext_t > * [_param->_nb_gpr_read];
141	out_GPR_READ_DATA = new sc_signal<Tgeneral_data_t> * [_param->_nb_gpr_read];
142	out_GPR_READ_DATA_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
143	out_GPR_READ_REGISTERFILE_VAL = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
144	in_GPR_READ_REGISTERFILE_ACK = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
145	in_GPR_READ_REGISTERFILE_DATA = new sc_signal<Tgeneral_data_t> ** [_param->_nb_ooo_engine];
146	out_GPR_READ_STATUS_VAL = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
147	in_GPR_READ_STATUS_ACK = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
148	in_GPR_READ_STATUS_DATA_VAL = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
149
150	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
151	{
152	out_GPR_READ_REGISTERFILE_VAL [i] = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
153	in_GPR_READ_REGISTERFILE_ACK [i] = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
154	in_GPR_READ_REGISTERFILE_DATA [i] = new sc_signal<Tgeneral_data_t> * [_param->_nb_gpr_read];
155	out_GPR_READ_STATUS_VAL [i] = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
156	in_GPR_READ_STATUS_ACK [i] = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
157	in_GPR_READ_STATUS_DATA_VAL [i] = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
158	}
159
160	for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
161	{
162	in_GPR_READ_VAL [j] = new sc_signal<Tcontrol_t > (rename.c_str());
163	out_GPR_READ_ACK [j] = new sc_signal<Tcontrol_t > (rename.c_str());
164	in_GPR_READ_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t > (rename.c_str());
165	out_GPR_READ_DATA [j] = new sc_signal<Tgeneral_data_t> (rename.c_str());
166	out_GPR_READ_DATA_VAL [j] = new sc_signal<Tcontrol_t > (rename.c_str());
167
168	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
169	{
170	out_GPR_READ_REGISTERFILE_VAL [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
171	in_GPR_READ_REGISTERFILE_ACK [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
172	in_GPR_READ_REGISTERFILE_DATA [i][j] = new sc_signal<Tgeneral_data_t> (rename.c_str());
173	out_GPR_READ_STATUS_VAL [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
174	in_GPR_READ_STATUS_ACK [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
175	in_GPR_READ_STATUS_DATA_VAL [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
176	}
177	}
178
179	// ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
180	in_SPR_READ_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
181	out_SPR_READ_ACK = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
182	in_SPR_READ_OOO_ENGINE_ID = new sc_signal<Tcontext_t > * [_param->_nb_spr_read];
183	out_SPR_READ_DATA = new sc_signal<Tspecial_data_t> * [_param->_nb_spr_read];
184	out_SPR_READ_DATA_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
185	out_SPR_READ_REGISTERFILE_VAL = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
186	in_SPR_READ_REGISTERFILE_ACK = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
187	in_SPR_READ_REGISTERFILE_DATA = new sc_signal<Tspecial_data_t> ** [_param->_nb_ooo_engine];
188	out_SPR_READ_STATUS_VAL = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
189	in_SPR_READ_STATUS_ACK = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
190	in_SPR_READ_STATUS_DATA_VAL = new sc_signal<Tcontrol_t > ** [_param->_nb_ooo_engine];
191
192	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
193	{
194	out_SPR_READ_REGISTERFILE_VAL [i] = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
195	in_SPR_READ_REGISTERFILE_ACK [i] = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
196	in_SPR_READ_REGISTERFILE_DATA [i] = new sc_signal<Tspecial_data_t> * [_param->_nb_spr_read];
197	out_SPR_READ_STATUS_VAL [i] = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
198	in_SPR_READ_STATUS_ACK [i] = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
199	in_SPR_READ_STATUS_DATA_VAL [i] = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
200	}
201
202	for (uint32_t j=0; j<_param->_nb_spr_read; j++)
203	{
204	in_SPR_READ_VAL [j] = new sc_signal<Tcontrol_t > (rename.c_str());
205	out_SPR_READ_ACK [j] = new sc_signal<Tcontrol_t > (rename.c_str());
206	in_SPR_READ_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t > (rename.c_str());
207	out_SPR_READ_DATA [j] = new sc_signal<Tspecial_data_t> (rename.c_str());
208	out_SPR_READ_DATA_VAL [j] = new sc_signal<Tcontrol_t > (rename.c_str());
209
210	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
211	{
212	out_SPR_READ_REGISTERFILE_VAL [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
213	in_SPR_READ_REGISTERFILE_ACK [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
214	in_SPR_READ_REGISTERFILE_DATA [i][j] = new sc_signal<Tspecial_data_t> (rename.c_str());
215	out_SPR_READ_STATUS_VAL [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
216	in_SPR_READ_STATUS_ACK [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
217	in_SPR_READ_STATUS_DATA_VAL [i][j] = new sc_signal<Tcontrol_t > (rename.c_str());
218	}
219	}
220
221	// ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
222	in_GPR_WRITE_VAL = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
223	out_GPR_WRITE_ACK = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
224	in_GPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t> * [_param->_nb_gpr_write];
225	out_GPR_WRITE_REGISTERFILE_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
226	in_GPR_WRITE_REGISTERFILE_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
227	out_GPR_WRITE_STATUS_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
228	in_GPR_WRITE_STATUS_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
229
230	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
231	{
232	out_GPR_WRITE_REGISTERFILE_VAL [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
233	in_GPR_WRITE_REGISTERFILE_ACK [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
234	out_GPR_WRITE_STATUS_VAL [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
235	in_GPR_WRITE_STATUS_ACK [i] = new sc_signal<Tcontrol_t> * [_param->_nb_gpr_write];
236	}
237
238	for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
239	{
240	in_GPR_WRITE_VAL [j] = new sc_signal<Tcontrol_t> (rename.c_str());
241	out_GPR_WRITE_ACK [j] = new sc_signal<Tcontrol_t> (rename.c_str());
242	in_GPR_WRITE_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t> (rename.c_str());
243
244	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
245	{
246	out_GPR_WRITE_REGISTERFILE_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
247	in_GPR_WRITE_REGISTERFILE_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
248	out_GPR_WRITE_STATUS_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
249	in_GPR_WRITE_STATUS_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());;
250	}
251	}
252
253	// ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
254	in_SPR_WRITE_VAL = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
255	out_SPR_WRITE_ACK = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
256	in_SPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t> * [_param->_nb_spr_write];
257	out_SPR_WRITE_REGISTERFILE_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
258	in_SPR_WRITE_REGISTERFILE_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
259	out_SPR_WRITE_STATUS_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
260	in_SPR_WRITE_STATUS_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
261
262	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
263	{
264	out_SPR_WRITE_REGISTERFILE_VAL [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
265	in_SPR_WRITE_REGISTERFILE_ACK [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
266	out_SPR_WRITE_STATUS_VAL [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
267	in_SPR_WRITE_STATUS_ACK [i] = new sc_signal<Tcontrol_t> * [_param->_nb_spr_write];
268	}
269
270	for (uint32_t j=0; j<_param->_nb_spr_write; j++)
271	{
272	in_SPR_WRITE_VAL [j] = new sc_signal<Tcontrol_t> (rename.c_str());
273	out_SPR_WRITE_ACK [j] = new sc_signal<Tcontrol_t> (rename.c_str());
274	in_SPR_WRITE_OOO_ENGINE_ID [j] = new sc_signal<Tcontext_t> (rename.c_str());
275
276	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
277	{
278	out_SPR_WRITE_REGISTERFILE_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
279	in_SPR_WRITE_REGISTERFILE_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
280	out_SPR_WRITE_STATUS_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
281	in_SPR_WRITE_STATUS_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
282	}
283	}
284
285	// ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
286	in_INSERT_ROB_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
287	out_INSERT_ROB_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
288	in_INSERT_ROB_RD_USE = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
289	in_INSERT_ROB_RE_USE = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
290	out_INSERT_ROB_GPR_STATUS_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
291	in_INSERT_ROB_GPR_STATUS_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
292	out_INSERT_ROB_SPR_STATUS_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
293	in_INSERT_ROB_SPR_STATUS_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
294
295	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
296	{
297	uint32_t x=_param->_nb_inst_insert_rob [i];
298
299	in_INSERT_ROB_VAL [i] = new sc_signal<Tcontrol_t> * [x];
300	out_INSERT_ROB_ACK [i] = new sc_signal<Tcontrol_t> * [x];
301	in_INSERT_ROB_RD_USE [i] = new sc_signal<Tcontrol_t> * [x];
302	in_INSERT_ROB_RE_USE [i] = new sc_signal<Tcontrol_t> * [x];
303	out_INSERT_ROB_GPR_STATUS_VAL [i] = new sc_signal<Tcontrol_t> * [x];
304	in_INSERT_ROB_GPR_STATUS_ACK [i] = new sc_signal<Tcontrol_t> * [x];
305	out_INSERT_ROB_SPR_STATUS_VAL [i] = new sc_signal<Tcontrol_t> * [x];
306	in_INSERT_ROB_SPR_STATUS_ACK [i] = new sc_signal<Tcontrol_t> * [x];
307
308	for (uint32_t j=0; j<x; j++)
309	{
310	in_INSERT_ROB_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
311	out_INSERT_ROB_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
312	in_INSERT_ROB_RD_USE [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
313	in_INSERT_ROB_RE_USE [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
314	out_INSERT_ROB_GPR_STATUS_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
315	in_INSERT_ROB_GPR_STATUS_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
316	out_INSERT_ROB_SPR_STATUS_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
317	in_INSERT_ROB_SPR_STATUS_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
318	}
319	}
320
321	// ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
322	in_RETIRE_ROB_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
323	out_RETIRE_ROB_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
324	in_RETIRE_ROB_RD_OLD_USE = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
325	in_RETIRE_ROB_RD_NEW_USE = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
326	in_RETIRE_ROB_RE_OLD_USE = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
327	in_RETIRE_ROB_RE_NEW_USE = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
328	out_RETIRE_ROB_GPR_STATUS_OLD_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
329	out_RETIRE_ROB_GPR_STATUS_NEW_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
330	in_RETIRE_ROB_GPR_STATUS_OLD_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
331	in_RETIRE_ROB_GPR_STATUS_NEW_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
332	out_RETIRE_ROB_SPR_STATUS_OLD_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
333	out_RETIRE_ROB_SPR_STATUS_NEW_VAL = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
334	in_RETIRE_ROB_SPR_STATUS_OLD_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
335	in_RETIRE_ROB_SPR_STATUS_NEW_ACK = new sc_signal<Tcontrol_t> ** [_param->_nb_ooo_engine];
336
337	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
338	{
339	uint32_t x=_param->_nb_inst_retire_rob [i];
340
341	in_RETIRE_ROB_VAL [i] = new sc_signal<Tcontrol_t> * [x];
342	out_RETIRE_ROB_ACK [i] = new sc_signal<Tcontrol_t> * [x];
343	in_RETIRE_ROB_RD_OLD_USE [i] = new sc_signal<Tcontrol_t> * [x];
344	in_RETIRE_ROB_RD_NEW_USE [i] = new sc_signal<Tcontrol_t> * [x];
345	in_RETIRE_ROB_RE_OLD_USE [i] = new sc_signal<Tcontrol_t> * [x];
346	in_RETIRE_ROB_RE_NEW_USE [i] = new sc_signal<Tcontrol_t> * [x];
347	out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i] = new sc_signal<Tcontrol_t> * [x];
348	out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i] = new sc_signal<Tcontrol_t> * [x];
349	in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i] = new sc_signal<Tcontrol_t> * [x];
350	in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i] = new sc_signal<Tcontrol_t> * [x];
351	out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i] = new sc_signal<Tcontrol_t> * [x];
352	out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i] = new sc_signal<Tcontrol_t> * [x];
353	in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i] = new sc_signal<Tcontrol_t> * [x];
354	in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i] = new sc_signal<Tcontrol_t> * [x];
355
356	for (uint32_t j=0; j<x; j++)
357	{
358	in_RETIRE_ROB_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
359	out_RETIRE_ROB_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
360	in_RETIRE_ROB_RD_OLD_USE [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
361	in_RETIRE_ROB_RD_NEW_USE [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
362	in_RETIRE_ROB_RE_OLD_USE [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
363	in_RETIRE_ROB_RE_NEW_USE [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
364	out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
365	in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
366	out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
367	in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
368	out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
369	in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
370	out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
371	in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j] = new sc_signal<Tcontrol_t> (rename.c_str());
372	}
373	}
374
375
376
377	/********************************************************
378	* Instanciation
379	********************************************************/
380
381	cout << "<" << name << "> Instanciation of _Register_unit_Glue" << endl;
382
383	((_Register_unit_Glue-> in_CLOCK )) (( in_CLOCK ));
384	((_Register_unit_Glue-> in_NRESET )) (( in_NRESET ));
385	((_Register_unit_Glue->out_CONST_0)) ((out_CONST_0));
386	((_Register_unit_Glue->out_CONST_1)) ((out_CONST_1));
387
388	for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
389	{
390	((_Register_unit_Glue-> in_GPR_READ_VAL [j]))(( in_GPR_READ_VAL [j]));
391	((_Register_unit_Glue->out_GPR_READ_ACK [j]))((out_GPR_READ_ACK [j]));
392	if (_param->_have_port_ooo_engine_id == true)
393	((_Register_unit_Glue-> in_GPR_READ_OOO_ENGINE_ID [j]))(( in_GPR_READ_OOO_ENGINE_ID [j]));
394	((_Register_unit_Glue->out_GPR_READ_DATA [j]))((out_GPR_READ_DATA [j]));
395	((_Register_unit_Glue->out_GPR_READ_DATA_VAL [j]))((out_GPR_READ_DATA_VAL [j]));
396
397	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
398	{
399	((_Register_unit_Glue->out_GPR_READ_REGISTERFILE_VAL [i][j]))((out_GPR_READ_REGISTERFILE_VAL [i][j]));
400	((_Register_unit_Glue-> in_GPR_READ_REGISTERFILE_ACK [i][j]))(( in_GPR_READ_REGISTERFILE_ACK [i][j]));
401	((_Register_unit_Glue-> in_GPR_READ_REGISTERFILE_DATA [i][j]))(( in_GPR_READ_REGISTERFILE_DATA [i][j]));
402	((_Register_unit_Glue->out_GPR_READ_STATUS_VAL [i][j]))((out_GPR_READ_STATUS_VAL [i][j]));
403	((_Register_unit_Glue-> in_GPR_READ_STATUS_ACK [i][j]))(( in_GPR_READ_STATUS_ACK [i][j]));
404	((_Register_unit_Glue-> in_GPR_READ_STATUS_DATA_VAL [i][j]))(( in_GPR_READ_STATUS_DATA_VAL [i][j]));
405	}
406	}
407
408	for (uint32_t j=0; j<_param->_nb_spr_read; j++)
409	{
410	((_Register_unit_Glue-> in_SPR_READ_VAL [j]))(( in_SPR_READ_VAL [j]));
411	((_Register_unit_Glue->out_SPR_READ_ACK [j]))((out_SPR_READ_ACK [j]));
412	if (_param->_have_port_ooo_engine_id == true)
413	((_Register_unit_Glue-> in_SPR_READ_OOO_ENGINE_ID [j]))(( in_SPR_READ_OOO_ENGINE_ID [j]));
414	((_Register_unit_Glue->out_SPR_READ_DATA [j]))((out_SPR_READ_DATA [j]));
415	((_Register_unit_Glue->out_SPR_READ_DATA_VAL [j]))((out_SPR_READ_DATA_VAL [j]));
416
417	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
418	{
419	((_Register_unit_Glue->out_SPR_READ_REGISTERFILE_VAL [i][j]))((out_SPR_READ_REGISTERFILE_VAL [i][j]));
420	((_Register_unit_Glue-> in_SPR_READ_REGISTERFILE_ACK [i][j]))(( in_SPR_READ_REGISTERFILE_ACK [i][j]));
421	((_Register_unit_Glue-> in_SPR_READ_REGISTERFILE_DATA [i][j]))(( in_SPR_READ_REGISTERFILE_DATA [i][j]));
422	((_Register_unit_Glue->out_SPR_READ_STATUS_VAL [i][j]))((out_SPR_READ_STATUS_VAL [i][j]));
423	((_Register_unit_Glue-> in_SPR_READ_STATUS_ACK [i][j]))(( in_SPR_READ_STATUS_ACK [i][j]));
424	((_Register_unit_Glue-> in_SPR_READ_STATUS_DATA_VAL [i][j]))(( in_SPR_READ_STATUS_DATA_VAL [i][j]));
425	}
426	}
427
428	for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
429	{
430	((_Register_unit_Glue-> in_GPR_WRITE_VAL [j]))(( in_GPR_WRITE_VAL [j]));
431	((_Register_unit_Glue->out_GPR_WRITE_ACK [j]))((out_GPR_WRITE_ACK [j]));
432	if (_param->_have_port_ooo_engine_id == true)
433	((_Register_unit_Glue-> in_GPR_WRITE_OOO_ENGINE_ID [j]))(( in_GPR_WRITE_OOO_ENGINE_ID [j]));
434
435	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
436	{
437	((_Register_unit_Glue->out_GPR_WRITE_REGISTERFILE_VAL [i][j]))((out_GPR_WRITE_REGISTERFILE_VAL [i][j]));
438	((_Register_unit_Glue-> in_GPR_WRITE_REGISTERFILE_ACK [i][j]))(( in_GPR_WRITE_REGISTERFILE_ACK [i][j]));
439	((_Register_unit_Glue->out_GPR_WRITE_STATUS_VAL [i][j]))((out_GPR_WRITE_STATUS_VAL [i][j]));
440	((_Register_unit_Glue-> in_GPR_WRITE_STATUS_ACK [i][j]))(( in_GPR_WRITE_STATUS_ACK [i][j]));
441	}
442	}
443
444	for (uint32_t j=0; j<_param->_nb_spr_write; j++)
445	{
446	((_Register_unit_Glue-> in_SPR_WRITE_VAL [j]))(( in_SPR_WRITE_VAL [j]));
447	((_Register_unit_Glue->out_SPR_WRITE_ACK [j]))((out_SPR_WRITE_ACK [j]));
448	if (_param->_have_port_ooo_engine_id == true)
449	((_Register_unit_Glue-> in_SPR_WRITE_OOO_ENGINE_ID [j]))(( in_SPR_WRITE_OOO_ENGINE_ID [j]));
450
451	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
452	{
453	((_Register_unit_Glue->out_SPR_WRITE_REGISTERFILE_VAL [i][j]))((out_SPR_WRITE_REGISTERFILE_VAL [i][j]));
454	((_Register_unit_Glue-> in_SPR_WRITE_REGISTERFILE_ACK [i][j]))(( in_SPR_WRITE_REGISTERFILE_ACK [i][j]));
455	((_Register_unit_Glue->out_SPR_WRITE_STATUS_VAL [i][j]))((out_SPR_WRITE_STATUS_VAL [i][j]));
456	((_Register_unit_Glue-> in_SPR_WRITE_STATUS_ACK [i][j]))(( in_SPR_WRITE_STATUS_ACK [i][j]));
457	}
458	}
459
460	// ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
461	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
462	{
463	uint32_t x=_param->_nb_inst_insert_rob [i];
464
465	for (uint32_t j=0; j<x; j++)
466	{
467	((_Register_unit_Glue-> in_INSERT_ROB_VAL [i][j])) (( in_INSERT_ROB_VAL [i][j]));
468	((_Register_unit_Glue->out_INSERT_ROB_ACK [i][j])) ((out_INSERT_ROB_ACK [i][j]));
469	((_Register_unit_Glue-> in_INSERT_ROB_RD_USE [i][j])) (( in_INSERT_ROB_RD_USE [i][j]));
470	((_Register_unit_Glue-> in_INSERT_ROB_RE_USE [i][j])) (( in_INSERT_ROB_RE_USE [i][j]));
471	((_Register_unit_Glue->out_INSERT_ROB_GPR_STATUS_VAL [i][j])) ((out_INSERT_ROB_GPR_STATUS_VAL [i][j]));
472	((_Register_unit_Glue-> in_INSERT_ROB_GPR_STATUS_ACK [i][j])) (( in_INSERT_ROB_GPR_STATUS_ACK [i][j]));
473	((_Register_unit_Glue->out_INSERT_ROB_SPR_STATUS_VAL [i][j])) ((out_INSERT_ROB_SPR_STATUS_VAL [i][j]));
474	((_Register_unit_Glue-> in_INSERT_ROB_SPR_STATUS_ACK [i][j])) (( in_INSERT_ROB_SPR_STATUS_ACK [i][j]));
475	}
476	}
477
478	// ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
479
480	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
481	{
482	uint32_t x=_param->_nb_inst_retire_rob [i];
483
484	for (uint32_t j=0; j<x; j++)
485	{
486	((_Register_unit_Glue-> in_RETIRE_ROB_VAL [i][j]))(( in_RETIRE_ROB_VAL [i][j]));
487	((_Register_unit_Glue->out_RETIRE_ROB_ACK [i][j]))((out_RETIRE_ROB_ACK [i][j]));
488	((_Register_unit_Glue-> in_RETIRE_ROB_RD_OLD_USE [i][j]))(( in_RETIRE_ROB_RD_OLD_USE [i][j]));
489	((_Register_unit_Glue-> in_RETIRE_ROB_RD_NEW_USE [i][j]))(( in_RETIRE_ROB_RD_NEW_USE [i][j]));
490	((_Register_unit_Glue-> in_RETIRE_ROB_RE_OLD_USE [i][j]))(( in_RETIRE_ROB_RE_OLD_USE [i][j]));
491	((_Register_unit_Glue-> in_RETIRE_ROB_RE_NEW_USE [i][j]))(( in_RETIRE_ROB_RE_NEW_USE [i][j]));
492	((_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]))((out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]));
493	((_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]))(( in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]));
494	((_Register_unit_Glue->out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]))((out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]));
495	((_Register_unit_Glue-> in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]))(( in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]));
496	((_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]))((out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]));
497	((_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]))(( in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]));
498	((_Register_unit_Glue->out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]))((out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]));
499	((_Register_unit_Glue-> in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]))(( in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]));
500	}
501	}
502
503	cout << "<" << name << "> Start Simulation ............" << endl;
504	Time * _time = new Time();
505
506	/********************************************************
507	* Simulation - Begin
508	********************************************************/
509
510	// Initialisation
511	const bool test_read = true;
512	const bool test_write = true;
513	const bool test_insert = true;
514	const bool test_retire = true;
515
516	const int32_t percent_transaction = 75;
517
518	const uint32_t seed = 0;
519	//const uint32_t seed = static_cast<uint32_t>(time(NULL));
520
521	srand(seed);
522
523	Tcontext_t context;
524	Tcontrol_t gpr_read_ack [_param->_nb_gpr_read];
525	Tgeneral_data_t gpr_read_data [_param->_nb_gpr_read];
526	Tcontrol_t gpr_read_data_val [_param->_nb_gpr_read];
527	Tcontrol_t gpr_read_registerfile_val [_param->_nb_ooo_engine][_param->_nb_gpr_read];
528	Tcontrol_t gpr_read_status_val [_param->_nb_ooo_engine][_param->_nb_gpr_read];
529
530	Tcontrol_t gpr_write_ack [_param->_nb_gpr_write];
531	Tcontrol_t gpr_write_registerfile_val [_param->_nb_ooo_engine][_param->_nb_gpr_write];
532	Tcontrol_t gpr_write_status_val [_param->_nb_ooo_engine][_param->_nb_gpr_write];
533
534	Tcontrol_t spr_read_ack [_param->_nb_spr_read];
535	Tspecial_data_t spr_read_data [_param->_nb_spr_read];
536	Tcontrol_t spr_read_data_val [_param->_nb_spr_read];
537	Tcontrol_t spr_read_registerfile_val [_param->_nb_ooo_engine][_param->_nb_spr_read];
538	Tcontrol_t spr_read_status_val [_param->_nb_ooo_engine][_param->_nb_spr_read];
539
540	Tcontrol_t spr_write_ack [_param->_nb_spr_write];
541	Tcontrol_t spr_write_registerfile_val [_param->_nb_ooo_engine][_param->_nb_spr_write];
542	Tcontrol_t spr_write_status_val [_param->_nb_ooo_engine][_param->_nb_spr_write];
543
544	uint32_t max_nb_inst_retire_rob = 0;
545
546	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
547	if (_param->_nb_inst_retire_rob [i] > max_nb_inst_retire_rob)
548	max_nb_inst_retire_rob = _param->_nb_inst_retire_rob [i];
549
550	Tcontrol_t retire_rob_ack [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
551	Tcontrol_t retire_rob_gpr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
552	Tcontrol_t retire_rob_gpr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
553	Tcontrol_t retire_rob_spr_status_new_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
554	Tcontrol_t retire_rob_spr_status_old_val [_param->_nb_ooo_engine][max_nb_inst_retire_rob];
555
556	uint32_t max_nb_inst_insert_rob = 0;
557
558	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
559	if (_param->_nb_inst_insert_rob [i] > max_nb_inst_insert_rob)
560	max_nb_inst_insert_rob = _param->_nb_inst_insert_rob [i];
561
562	Tcontrol_t insert_rob_ack [_param->_nb_ooo_engine][max_nb_inst_insert_rob];
563	Tcontrol_t insert_rob_gpr_status_val [_param->_nb_ooo_engine][max_nb_inst_insert_rob];
564	Tcontrol_t insert_rob_spr_status_val [_param->_nb_ooo_engine][max_nb_inst_insert_rob];
565
566	SC_START(0);
567	LABEL("Initialisation");
568
569	in_NRESET->write(0);
570	SC_START(5);
571	in_NRESET->write(1);
572
573	LABEL("Loop of Test");
574
575	for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
576	{
577	LABEL("Iteration "+toString(iteration));
578
579	if (test_read == true)
580	{
581	for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
582	{
583	context = (rand())%_param->_nb_ooo_engine;
584	Tcontrol_t val = (rand()%100)<=percent_transaction;
585
586	LABEL("GPR_READ ["+toString(j)+"] : "+toString(val)+" - " +toString(static_cast<uint32_t>(context)));
587
588	in_GPR_READ_VAL [j] ->write(val);
589	in_GPR_READ_OOO_ENGINE_ID [j] ->write(context);
590
591	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
592	{
593	Tcontrol_t registerfile_ack = (rand()%100)<=percent_transaction ;
594	Tgeneral_data_t registerfile_data = (rand()%_param->_size_general_data);
595	Tcontrol_t status_ack = (rand()%100)<=percent_transaction ;
596	Tcontrol_t status_data_val = (rand()%100)<=percent_transaction ;
597
598	in_GPR_READ_REGISTERFILE_ACK [i][j]->write(registerfile_ack );
599	in_GPR_READ_REGISTERFILE_DATA [i][j]->write(registerfile_data);
600	in_GPR_READ_STATUS_ACK [i][j]->write(status_ack );
601	in_GPR_READ_STATUS_DATA_VAL [i][j]->write(status_data_val );
602
603	if (i == context)
604	{
605	gpr_read_registerfile_val [i][j] = val and status_ack ;
606	gpr_read_status_val [i][j] = val and registerfile_ack;
607
608	gpr_read_ack [j] = registerfile_ack and status_ack;
609	gpr_read_data [j] = registerfile_data;
610	gpr_read_data_val [j] = status_data_val;
611	}
612	else
613	{
614	gpr_read_registerfile_val [i][j] = 0;
615	gpr_read_status_val [i][j] = 0;
616	}
617	}
618	}
619
620	for (uint32_t j=0; j<_param->_nb_spr_read; j++)
621	{
622	context = (rand())%_param->_nb_ooo_engine;
623	Tcontrol_t val = (rand()%100)<=percent_transaction;
624
625	LABEL("SPR_READ ["+toString(j)+"] : "+toString(val)+" - " +toString(static_cast<uint32_t>(context)));
626
627	in_SPR_READ_VAL [j] ->write(val);
628	in_SPR_READ_OOO_ENGINE_ID [j] ->write(context);
629
630	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
631	{
632	Tcontrol_t registerfile_ack = (rand()%100)<=percent_transaction ;
633	Tspecial_data_t registerfile_data = (rand()%_param->_size_special_data);
634	Tcontrol_t status_ack = (rand()%100)<=percent_transaction ;
635	Tcontrol_t status_data_val = (rand()%100)<=percent_transaction ;
636
637	in_SPR_READ_REGISTERFILE_ACK [i][j]->write(registerfile_ack );
638	in_SPR_READ_REGISTERFILE_DATA [i][j]->write(registerfile_data);
639	in_SPR_READ_STATUS_ACK [i][j]->write(status_ack );
640	in_SPR_READ_STATUS_DATA_VAL [i][j]->write(status_data_val );
641
642	if (i == context)
643	{
644	spr_read_registerfile_val [i][j] = val and status_ack ;
645	spr_read_status_val [i][j] = val and registerfile_ack;
646
647	spr_read_ack [j] = registerfile_ack and status_ack;
648	spr_read_data [j] = registerfile_data;
649	spr_read_data_val [j] = status_data_val;
650	}
651	else
652	{
653	spr_read_registerfile_val [i][j] = 0;
654	spr_read_status_val [i][j] = 0;
655	}
656
657	}
658	}
659	}
660
661	if (test_write == true)
662	{
663	for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
664	{
665	context = (rand())%_param->_nb_ooo_engine;
666	Tcontrol_t val = (rand()%100)<=percent_transaction;
667
668	LABEL("GPR_WRITE ["+toString(j)+"] : "+toString(val)+" - " +toString(static_cast<uint32_t>(context)));
669
670	in_GPR_WRITE_VAL [j] ->write(val);
671	in_GPR_WRITE_OOO_ENGINE_ID [j] ->write(context);
672
673	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
674	{
675	Tcontrol_t registerfile_ack = (rand()%100)<=percent_transaction ;
676	Tcontrol_t status_ack = (rand()%100)<=percent_transaction ;
677
678	in_GPR_WRITE_REGISTERFILE_ACK [i][j]->write(registerfile_ack );
679	in_GPR_WRITE_STATUS_ACK [i][j]->write(status_ack );
680
681
682	if (i == context)
683	{
684	gpr_write_registerfile_val [i][j] = val and status_ack ;
685	gpr_write_status_val [i][j] = val and registerfile_ack;
686
687	gpr_write_ack [j] = registerfile_ack and status_ack;
688	}
689	else
690	{
691	gpr_write_registerfile_val [i][j] = 0;
692	gpr_write_status_val [i][j] = 0;
693	}
694
695	}
696	}
697
698	for (uint32_t j=0; j<_param->_nb_spr_write; j++)
699	{
700	context = (rand())%_param->_nb_ooo_engine;
701	Tcontrol_t val = (rand()%100)<=percent_transaction;
702
703	LABEL("SPR_WRITE ["+toString(j)+"] : "+toString(val)+" - " +toString(static_cast<uint32_t>(context)));
704
705	in_SPR_WRITE_VAL [j] ->write(val);
706	in_SPR_WRITE_OOO_ENGINE_ID [j] ->write(context);
707
708	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
709	{
710	Tcontrol_t registerfile_ack = (rand()%100)<=percent_transaction ;
711	Tcontrol_t status_ack = (rand()%100)<=percent_transaction ;
712
713	in_SPR_WRITE_REGISTERFILE_ACK [i][j]->write(registerfile_ack );
714	in_SPR_WRITE_STATUS_ACK [i][j]->write(status_ack );
715
716
717	if (i == context)
718	{
719	spr_write_registerfile_val [i][j] = val and status_ack ;
720	spr_write_status_val [i][j] = val and registerfile_ack;
721
722	spr_write_ack [j] = registerfile_ack and status_ack;
723	}
724	else
725	{
726	spr_write_registerfile_val [i][j] = 0;
727	spr_write_status_val [i][j] = 0;
728	}
729	}
730	}
731	}
732
733	if (test_retire == true)
734	{
735	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
736	{
737	uint32_t x = _param->_nb_inst_retire_rob [i];
738
739	for (uint32_t j=0; j<x; j++)
740	{
741	Tcontrol_t val = (rand()%100)<=percent_transaction;
742	Tcontrol_t rd_old_use = (rand()%100)<=percent_transaction;
743	Tcontrol_t rd_new_use = (rand()%100)<=percent_transaction;
744	Tcontrol_t re_old_use = (rand()%100)<=percent_transaction;
745	Tcontrol_t re_new_use = (rand()%100)<=percent_transaction;
746	Tcontrol_t gpr_status_old_ack = (rand()%100)<=percent_transaction;
747	Tcontrol_t gpr_status_new_ack = (rand()%100)<=percent_transaction;
748	Tcontrol_t spr_status_old_ack = (rand()%100)<=percent_transaction;
749	Tcontrol_t spr_status_new_ack = (rand()%100)<=percent_transaction;
750
751	in_RETIRE_ROB_VAL [i][j]->write(val );
752	in_RETIRE_ROB_RD_OLD_USE [i][j]->write(rd_old_use );
753	in_RETIRE_ROB_RD_NEW_USE [i][j]->write(rd_new_use );
754	in_RETIRE_ROB_RE_OLD_USE [i][j]->write(re_old_use );
755	in_RETIRE_ROB_RE_NEW_USE [i][j]->write(re_new_use );
756	in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j]->write(gpr_status_old_ack);
757	in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j]->write(gpr_status_new_ack);
758	in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j]->write(spr_status_old_ack);
759	in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j]->write(spr_status_new_ack);
760
761	retire_rob_ack [i][j] = (gpr_status_new_ack and
762	gpr_status_old_ack and
763	spr_status_new_ack and
764	spr_status_old_ack);
765
766
767	retire_rob_gpr_status_old_val [i][j] = val and rd_old_use and gpr_status_new_ack and spr_status_old_ack and spr_status_new_ack;
768	retire_rob_gpr_status_new_val [i][j] = val and rd_new_use and gpr_status_old_ack and spr_status_old_ack and spr_status_new_ack;
769	retire_rob_spr_status_old_val [i][j] = val and re_old_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_new_ack;
770	retire_rob_spr_status_new_val [i][j] = val and re_new_use and gpr_status_old_ack and gpr_status_new_ack and spr_status_old_ack ;
771	}
772	}
773	}
774
775	if (test_insert == true)
776	{
777	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
778	{
779	uint32_t x = _param->_nb_inst_insert_rob [i];
780
781	for (uint32_t j=0; j<x; j++)
782	{
783	Tcontrol_t val = (rand()%100)<=percent_transaction;
784	Tcontrol_t rd_use = (rand()%100)<=percent_transaction;
785	Tcontrol_t re_use = (rand()%100)<=percent_transaction;
786	Tcontrol_t gpr_status_ack = (rand()%100)<=percent_transaction;
787	Tcontrol_t spr_status_ack = (rand()%100)<=percent_transaction;
788
789	in_INSERT_ROB_VAL [i][j]->write(val );
790	in_INSERT_ROB_RD_USE [i][j]->write(rd_use );
791	in_INSERT_ROB_RE_USE [i][j]->write(re_use );
792	in_INSERT_ROB_GPR_STATUS_ACK [i][j]->write(gpr_status_ack);
793	in_INSERT_ROB_SPR_STATUS_ACK [i][j]->write(spr_status_ack);
794
795	insert_rob_ack [i][j] = (gpr_status_ack and
796	spr_status_ack);
797
798
799	insert_rob_gpr_status_val [i][j] = val and rd_use and spr_status_ack;
800	insert_rob_spr_status_val [i][j] = val and re_use and gpr_status_ack ;
801	}
802	}
803	}
804
805	SC_START(0);
806
807	// Test
808	TEST(Tcontrol_t, out_CONST_0->read() , 0);
809	TEST(Tcontrol_t, out_CONST_1->read() , 1);
810
811	if (test_read == true)
812	{
813	for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
814	{
815	TEST(Tcontrol_t , out_GPR_READ_ACK [j]->read(), gpr_read_ack [j]);
816	TEST(Tgeneral_data_t, out_GPR_READ_DATA [j]->read(), gpr_read_data [j]);
817	TEST(Tcontrol_t , out_GPR_READ_DATA_VAL [j]->read(), gpr_read_data_val[j]);
818
819	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
820	{
821	TEST(Tcontrol_t, out_GPR_READ_REGISTERFILE_VAL [i][j]->read(), gpr_read_registerfile_val [i][j]);
822	TEST(Tcontrol_t, out_GPR_READ_STATUS_VAL [i][j]->read(), gpr_read_status_val [i][j]);
823	}
824	}
825	for (uint32_t j=0; j<_param->_nb_spr_read; j++)
826	{
827	TEST(Tcontrol_t , out_SPR_READ_ACK [j]->read(), spr_read_ack [j]);
828	TEST(Tspecial_data_t, out_SPR_READ_DATA [j]->read(), spr_read_data [j]);
829	TEST(Tcontrol_t , out_SPR_READ_DATA_VAL [j]->read(), spr_read_data_val[j]);
830
831	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
832	{
833	TEST(Tcontrol_t, out_SPR_READ_REGISTERFILE_VAL [i][j]->read(), spr_read_registerfile_val [i][j]);
834	TEST(Tcontrol_t, out_SPR_READ_STATUS_VAL [i][j]->read(), spr_read_status_val [i][j]);
835	}
836	}
837	}
838
839	if (test_write == true)
840	{
841	for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
842	{
843	TEST(Tcontrol_t , out_GPR_WRITE_ACK [j]->read(), gpr_write_ack [j]);
844
845	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
846	{
847	TEST(Tcontrol_t, out_GPR_WRITE_REGISTERFILE_VAL [i][j]->read(), gpr_write_registerfile_val [i][j]);
848	TEST(Tcontrol_t, out_GPR_WRITE_STATUS_VAL [i][j]->read(), gpr_write_status_val [i][j]);
849	}
850	}
851	for (uint32_t j=0; j<_param->_nb_spr_write; j++)
852	{
853	TEST(Tcontrol_t , out_SPR_WRITE_ACK [j]->read(), spr_write_ack [j]);
854
855	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
856	{
857	TEST(Tcontrol_t, out_SPR_WRITE_REGISTERFILE_VAL [i][j]->read(), spr_write_registerfile_val [i][j]);
858	TEST(Tcontrol_t, out_SPR_WRITE_STATUS_VAL [i][j]->read(), spr_write_status_val [i][j]);
859	}
860	}
861	}
862
863
864	if (test_retire == true)
865	{
866	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
867	{
868	uint32_t x = _param->_nb_inst_retire_rob [i];
869
870	for (uint32_t j=0; j<x; j++)
871	{
872	TEST(Tcontrol_t, out_RETIRE_ROB_ACK [i][j]->read(), retire_rob_ack [i][j]);
873	TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_gpr_status_old_val [i][j]);
874	TEST(Tcontrol_t, out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_gpr_status_new_val [i][j]);
875	TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j]->read(), retire_rob_spr_status_old_val [i][j]);
876	TEST(Tcontrol_t, out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j]->read(), retire_rob_spr_status_new_val [i][j]);
877	}
878	}
879	}
880
881	if (test_insert == true)
882	{
883	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
884	{
885	uint32_t x = _param->_nb_inst_insert_rob [i];
886
887	for (uint32_t j=0; j<x; j++)
888	{
889	TEST(Tcontrol_t, out_INSERT_ROB_ACK [i][j]->read(), insert_rob_ack [i][j]);
890	TEST(Tcontrol_t, out_INSERT_ROB_GPR_STATUS_VAL [i][j]->read(), insert_rob_gpr_status_val [i][j]);
891	TEST(Tcontrol_t, out_INSERT_ROB_SPR_STATUS_VAL [i][j]->read(), insert_rob_spr_status_val [i][j]);
892	}
893	}
894	}
895
896
897	SC_START(1);
898	}
899
900	/********************************************************
901	* Simulation - End
902	********************************************************/
903
904	TEST_OK ("End of Simulation");
905	delete _time;
906	cout << "<" << name << "> ............ Stop Simulation" << endl;
907
908	delete in_CLOCK;
909	delete in_NRESET;
910	delete [] in_GPR_READ_VAL ;
911	delete [] out_GPR_READ_ACK ;
912	delete [] in_GPR_READ_OOO_ENGINE_ID ;
913	delete [] out_GPR_READ_DATA ;
914	delete [] out_GPR_READ_DATA_VAL ;
915	delete [] out_GPR_READ_REGISTERFILE_VAL ;
916	delete [] in_GPR_READ_REGISTERFILE_ACK ;
917	delete [] in_GPR_READ_REGISTERFILE_DATA ;
918	delete [] out_GPR_READ_STATUS_VAL ;
919	delete [] in_GPR_READ_STATUS_ACK ;
920	delete [] in_GPR_READ_STATUS_DATA_VAL ;
921	delete [] in_SPR_READ_VAL ;
922	delete [] out_SPR_READ_ACK ;
923	delete [] in_SPR_READ_OOO_ENGINE_ID ;
924	delete [] out_SPR_READ_DATA ;
925	delete [] out_SPR_READ_DATA_VAL ;
926	delete [] out_SPR_READ_REGISTERFILE_VAL ;
927	delete [] in_SPR_READ_REGISTERFILE_ACK ;
928	delete [] in_SPR_READ_REGISTERFILE_DATA ;
929	delete [] out_SPR_READ_STATUS_VAL ;
930	delete [] in_SPR_READ_STATUS_ACK ;
931	delete [] in_SPR_READ_STATUS_DATA_VAL ;
932	delete [] in_GPR_WRITE_VAL ;
933	delete [] out_GPR_WRITE_ACK ;
934	delete [] in_GPR_WRITE_OOO_ENGINE_ID ;
935	delete [] out_GPR_WRITE_REGISTERFILE_VAL ;
936	delete [] in_GPR_WRITE_REGISTERFILE_ACK ;
937	delete [] out_GPR_WRITE_STATUS_VAL ;
938	delete [] in_GPR_WRITE_STATUS_ACK ;
939	delete [] in_SPR_WRITE_VAL ;
940	delete [] out_SPR_WRITE_ACK ;
941	delete [] in_SPR_WRITE_OOO_ENGINE_ID ;
942	delete [] out_SPR_WRITE_REGISTERFILE_VAL ;
943	delete [] in_SPR_WRITE_REGISTERFILE_ACK ;
944	delete [] out_SPR_WRITE_STATUS_VAL ;
945	delete [] in_SPR_WRITE_STATUS_ACK ;
946	delete [] in_INSERT_ROB_VAL ;
947	delete [] out_INSERT_ROB_ACK ;
948	delete [] in_INSERT_ROB_RD_USE ;
949	delete [] in_INSERT_ROB_RE_USE ;
950	delete [] out_INSERT_ROB_GPR_STATUS_VAL ;
951	delete [] in_INSERT_ROB_GPR_STATUS_ACK ;
952	delete [] out_INSERT_ROB_SPR_STATUS_VAL ;
953	delete [] in_INSERT_ROB_SPR_STATUS_ACK ;
954	delete [] in_RETIRE_ROB_VAL ;
955	delete [] out_RETIRE_ROB_ACK ;
956	delete [] in_RETIRE_ROB_RD_OLD_USE ;
957	delete [] in_RETIRE_ROB_RD_NEW_USE ;
958	delete [] in_RETIRE_ROB_RE_OLD_USE ;
959	delete [] in_RETIRE_ROB_RE_NEW_USE ;
960	delete [] out_RETIRE_ROB_GPR_STATUS_OLD_VAL ;
961	delete [] out_RETIRE_ROB_GPR_STATUS_NEW_VAL ;
962	delete [] in_RETIRE_ROB_GPR_STATUS_OLD_ACK ;
963	delete [] in_RETIRE_ROB_GPR_STATUS_NEW_ACK ;
964	delete [] out_RETIRE_ROB_SPR_STATUS_OLD_VAL ;
965	delete [] out_RETIRE_ROB_SPR_STATUS_NEW_VAL ;
966	delete [] in_RETIRE_ROB_SPR_STATUS_OLD_ACK ;
967	delete [] in_RETIRE_ROB_SPR_STATUS_NEW_ACK ;
968
969	#endif
970
971	delete _Register_unit_Glue;
972	#ifdef STATISTICS
973	delete _parameters_statistics;
974	#endif
975	}

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

Download in other formats: