Context Navigation

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

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

Download in other formats: