Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/src/test.cpp @ 66

Last change on this file since 66 was 66, checked in by rosiere, 17 years ago
un pas de plus vers la compatibilite avec systemC modification de l'interface de read_queue : context_id devient context_id, front_end_id et ooo_engine_id
File size: 33.9 KB

Line
1	/*
2	* $Id$
3	*
4	* [ Description ]
5	*
6	* Test
7	*/
8
9	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/SelfTest/include/test.h"
10	#include "Common/include/Test.h"
11
12	#define NB_ITERATION 1
13	//64
14	#define CYCLE_MAX (1024*NB_ITERATION)
15
16	#define LABEL(str) \
17	{ \
18	cout << "{"+toString(static_cast<uint32_t>(sc_simulation_time()))+"} " << str << endl; \
19	} while(0)
20
21	static uint32_t cycle = 0;
22
23	#define SC_START(cycle_offset) \
24	do \
25	{ \
26	/cout << "SC_START (begin)" << endl;/ \
27	\
28	uint32_t cycle_current = static_cast<uint32_t>(sc_simulation_time()); \
29	if (cycle_current != cycle) \
30	{ \
31	cycle = cycle_current; \
32	cout << "##########[ cycle "<< cycle << " ]" << endl; \
33	} \
34	\
35	if (cycle_current > CYCLE_MAX) \
36	{ \
37	TEST_KO("Maximal cycles Reached"); \
38	} \
39	sc_start(cycle_offset); \
40	/cout << "SC_START (end )" << endl;/ \
41	} while(0)
42
43	void test (string name,
44	morpheo::behavioural::core::multi_execute_loop::execute_loop::multi_read_unit::read_unit::read_queue::Parameters * _param)
45	{
46	cout << "<" << name << "> : Simulation SystemC" << endl;
47
48	#ifdef STATISTICS
49	morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
50	#endif
51
52	Read_queue * _Read_queue = new Read_queue (name.c_str(),
53	#ifdef STATISTICS
54	_parameters_statistics,
55	#endif
56	_param);
57
58	#ifdef SYSTEMC
59	/*********************************************************************
60	* Déclarations des signaux
61	*********************************************************************/
62	string rename;
63
64	sc_clock * CLOCK = new sc_clock ("clock", 1.0, 0.5);
65	sc_signal<Tcontrol_t> * NRESET= new sc_signal<Tcontrol_t> ("NRESET");
66
67	// ~~~~~[ Interface "read_queue_in" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
68
69	sc_signal<Tcontrol_t > * READ_QUEUE_IN_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_VAL ");
70	sc_signal<Tcontrol_t > * READ_QUEUE_IN_ACK = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_ACK ");
71	sc_signal<Tcontext_t > * READ_QUEUE_IN_CONTEXT_ID = new sc_signal<Tcontext_t > ("READ_QUEUE_IN_CONTEXT_ID ");
72	sc_signal<Tcontext_t > * READ_QUEUE_IN_FRONT_END_ID = new sc_signal<Tcontext_t > ("READ_QUEUE_IN_FRONT_END_ID ");
73	sc_signal<Tcontext_t > * READ_QUEUE_IN_OOO_ENGINE_ID= new sc_signal<Tcontext_t > ("READ_QUEUE_IN_OOO_ENGINE_ID");
74	sc_signal<Tpacket_t > * READ_QUEUE_IN_ROB_ID = new sc_signal<Tpacket_t > ("READ_QUEUE_IN_ROB_ID ");
75	sc_signal<Toperation_t > * READ_QUEUE_IN_OPERATION = new sc_signal<Toperation_t > ("READ_QUEUE_IN_OPERATION ");
76	sc_signal<Ttype_t > * READ_QUEUE_IN_TYPE = new sc_signal<Ttype_t > ("READ_QUEUE_IN_TYPE ");
77	sc_signal<Tcontrol_t > * READ_QUEUE_IN_HAS_IMMEDIAT = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_HAS_IMMEDIAT");
78	sc_signal<Tgeneral_data_t > * READ_QUEUE_IN_IMMEDIAT = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_IN_IMMEDIAT ");
79	sc_signal<Tcontrol_t > * READ_QUEUE_IN_READ_RA = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_READ_RA ");
80	sc_signal<Tgeneral_address_t > * READ_QUEUE_IN_NUM_REG_RA = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_IN_NUM_REG_RA ");
81	sc_signal<Tcontrol_t > * READ_QUEUE_IN_READ_RB = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_READ_RB ");
82	sc_signal<Tgeneral_address_t > * READ_QUEUE_IN_NUM_REG_RB = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_IN_NUM_REG_RB ");
83	sc_signal<Tcontrol_t > * READ_QUEUE_IN_READ_RC = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_READ_RC ");
84	sc_signal<Tspecial_address_t > * READ_QUEUE_IN_NUM_REG_RC = new sc_signal<Tspecial_address_t > ("READ_QUEUE_IN_NUM_REG_RC ");
85	sc_signal<Tcontrol_t > * READ_QUEUE_IN_WRITE_RD = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_WRITE_RD ");
86	sc_signal<Tgeneral_address_t > * READ_QUEUE_IN_NUM_REG_RD = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_IN_NUM_REG_RD ");
87	sc_signal<Tcontrol_t > * READ_QUEUE_IN_WRITE_RE = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_WRITE_RE ");
88	sc_signal<Tspecial_address_t > * READ_QUEUE_IN_NUM_REG_RE = new sc_signal<Tspecial_address_t > ("READ_QUEUE_IN_NUM_REG_RE ");
89
90	// ~~~~~[ Interface "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
91
92	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_VAL ");
93	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_ACK = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_ACK ");
94	sc_signal<Tcontext_t > * READ_QUEUE_OUT_CONTEXT_ID = new sc_signal<Tcontext_t > ("READ_QUEUE_OUT_CONTEXT_ID ");
95	sc_signal<Tcontext_t > * READ_QUEUE_OUT_FRONT_END_ID = new sc_signal<Tcontext_t > ("READ_QUEUE_OUT_FRONT_END_ID ");
96	sc_signal<Tcontext_t > * READ_QUEUE_OUT_OOO_ENGINE_ID = new sc_signal<Tcontext_t > ("READ_QUEUE_OUT_OOO_ENGINE_ID");
97	sc_signal<Tpacket_t > * READ_QUEUE_OUT_ROB_ID = new sc_signal<Tpacket_t > ("READ_QUEUE_OUT_ROB_ID ");
98	sc_signal<Toperation_t > * READ_QUEUE_OUT_OPERATION = new sc_signal<Toperation_t > ("READ_QUEUE_OUT_OPERATION ");
99	sc_signal<Ttype_t > * READ_QUEUE_OUT_TYPE = new sc_signal<Ttype_t > ("READ_QUEUE_OUT_TYPE ");
100	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_HAS_IMMEDIAT= new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_HAS_IMMEDIAT");
101	sc_signal<Tgeneral_data_t > * READ_QUEUE_OUT_IMMEDIAT = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_OUT_IMMEDIAT ");
102	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_READ_RA = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_READ_RA ");
103	sc_signal<Tgeneral_address_t > * READ_QUEUE_OUT_NUM_REG_RA = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_OUT_NUM_REG_RA ");
104	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_DATA_RA_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_DATA_RA_VAL ");
105	sc_signal<Tgeneral_data_t > * READ_QUEUE_OUT_DATA_RA = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_OUT_DATA_RA ");
106	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_READ_RB = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_READ_RB ");
107	sc_signal<Tgeneral_address_t > * READ_QUEUE_OUT_NUM_REG_RB = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_OUT_NUM_REG_RB ");
108	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_DATA_RB_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_DATA_RB_VAL ");
109	sc_signal<Tgeneral_data_t > * READ_QUEUE_OUT_DATA_RB = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_OUT_DATA_RB ");
110	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_READ_RC = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_READ_RC ");
111	sc_signal<Tspecial_address_t > * READ_QUEUE_OUT_NUM_REG_RC = new sc_signal<Tspecial_address_t > ("READ_QUEUE_OUT_NUM_REG_RC ");
112	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_DATA_RC_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_DATA_RC_VAL ");
113	sc_signal<Tspecial_data_t > * READ_QUEUE_OUT_DATA_RC = new sc_signal<Tspecial_data_t > ("READ_QUEUE_OUT_DATA_RC ");
114	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_WRITE_RD = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_WRITE_RD ");
115	sc_signal<Tgeneral_address_t > * READ_QUEUE_OUT_NUM_REG_RD = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_OUT_NUM_REG_RD ");
116	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_WRITE_RE = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_WRITE_RE ");
117	sc_signal<Tspecial_address_t > * READ_QUEUE_OUT_NUM_REG_RE = new sc_signal<Tspecial_address_t > ("READ_QUEUE_OUT_NUM_REG_RE ");
118
119	// ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
120
121	sc_signal<Tcontrol_t > ** GPR_READ_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
122	sc_signal<Tcontrol_t > ** GPR_READ_ACK = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
123	sc_signal<Tcontext_t > ** GPR_READ_OOO_ENGINE_ID = new sc_signal<Tcontext_t > * [_param->_nb_gpr_read];
124	sc_signal<Tgeneral_address_t > ** GPR_READ_NUM_REG = new sc_signal<Tgeneral_address_t > * [_param->_nb_gpr_read];
125	sc_signal<Tgeneral_data_t > ** GPR_READ_DATA = new sc_signal<Tgeneral_data_t > * [_param->_nb_gpr_read];
126	sc_signal<Tcontrol_t > ** GPR_READ_DATA_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
127
128	for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
129	{
130	rename = "GPR_READ_"+toString(i)+"_VAL";
131	GPR_READ_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
132	rename = "GPR_READ_"+toString(i)+"_ACK";
133	GPR_READ_ACK [i] = new sc_signal<Tcontrol_t > (rename.c_str());
134	rename = "GPR_READ_"+toString(i)+"_OOO_ENGINE_ID";
135	GPR_READ_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
136	rename = "GPR_READ_"+toString(i)+"_NUM_REG";
137	GPR_READ_NUM_REG [i] = new sc_signal<Tgeneral_address_t > (rename.c_str());
138	rename = "GPR_READ_"+toString(i)+"_DATA";
139	GPR_READ_DATA [i] = new sc_signal<Tgeneral_data_t > (rename.c_str());
140	rename = "GPR_READ_"+toString(i)+"_DATA_VAL";
141	GPR_READ_DATA_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
142	}
143
144	// ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
145
146	sc_signal<Tcontrol_t > ** SPR_READ_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
147	sc_signal<Tcontrol_t > ** SPR_READ_ACK = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
148	sc_signal<Tcontext_t > ** SPR_READ_OOO_ENGINE_ID = new sc_signal<Tcontext_t > * [_param->_nb_spr_read];
149	sc_signal<Tspecial_address_t > ** SPR_READ_NUM_REG = new sc_signal<Tspecial_address_t > * [_param->_nb_spr_read];
150	sc_signal<Tspecial_data_t > ** SPR_READ_DATA = new sc_signal<Tspecial_data_t > * [_param->_nb_spr_read];
151	sc_signal<Tcontrol_t > ** SPR_READ_DATA_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
152
153	for (uint32_t i=0; i<_param->_nb_spr_read; i++)
154	{
155	rename = "SPR_READ_"+toString(i)+"_VAL";
156	SPR_READ_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
157	rename = "SPR_READ_"+toString(i)+"_ACK";
158	SPR_READ_ACK [i] = new sc_signal<Tcontrol_t > (rename.c_str());
159	rename = "SPR_READ_"+toString(i)+"_OOO_ENGINE_ID";
160	SPR_READ_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
161	rename = "SPR_READ_"+toString(i)+"_NUM_REG";
162	SPR_READ_NUM_REG [i] = new sc_signal<Tspecial_address_t > (rename.c_str());
163	rename = "SPR_READ_"+toString(i)+"_DATA";
164	SPR_READ_DATA [i] = new sc_signal<Tspecial_data_t > (rename.c_str());
165	rename = "SPR_READ_"+toString(i)+"_DATA_VAL";
166	SPR_READ_DATA_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
167	}
168
169	// ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
170
171	sc_signal<Tcontrol_t > ** GPR_WRITE_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_write];
172	sc_signal<Tcontext_t > ** GPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t > * [_param->_nb_gpr_write];
173	sc_signal<Tgeneral_address_t > ** GPR_WRITE_NUM_REG = new sc_signal<Tgeneral_address_t > * [_param->_nb_gpr_write];
174	sc_signal<Tgeneral_data_t > ** GPR_WRITE_DATA = new sc_signal<Tgeneral_data_t > * [_param->_nb_gpr_write];
175
176	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
177	{
178	rename = "GPR_WRITE_"+toString(i)+"_VAL" ;
179	GPR_WRITE_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
180	rename = "GPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID";
181	GPR_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
182	rename = "GPR_WRITE_"+toString(i)+"_NUM_REG" ;
183	GPR_WRITE_NUM_REG [i] = new sc_signal<Tgeneral_address_t > (rename.c_str());
184	rename = "GPR_WRITE_"+toString(i)+"_DATA" ;
185	GPR_WRITE_DATA [i] = new sc_signal<Tgeneral_data_t > (rename.c_str());
186	}
187
188	// ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
189
190	sc_signal<Tcontrol_t > ** SPR_WRITE_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_write];
191	sc_signal<Tcontext_t > ** SPR_WRITE_OOO_ENGINE_ID = new sc_signal<Tcontext_t > * [_param->_nb_spr_write];
192	sc_signal<Tspecial_address_t > ** SPR_WRITE_NUM_REG = new sc_signal<Tspecial_address_t > * [_param->_nb_spr_write];
193	sc_signal<Tspecial_data_t > ** SPR_WRITE_DATA = new sc_signal<Tspecial_data_t > * [_param->_nb_spr_write];
194
195	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
196	{
197	rename = "SPR_WRITE_"+toString(i)+"_VAL" ;
198	SPR_WRITE_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
199	rename = "SPR_WRITE_"+toString(i)+"_OOO_ENGINE_ID";
200	SPR_WRITE_OOO_ENGINE_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
201	rename = "SPR_WRITE_"+toString(i)+"_NUM_REG" ;
202	SPR_WRITE_NUM_REG [i] = new sc_signal<Tspecial_address_t > (rename.c_str());
203	rename = "SPR_WRITE_"+toString(i)+"_DATA" ;
204	SPR_WRITE_DATA [i] = new sc_signal<Tspecial_data_t > (rename.c_str());
205	}
206
207	/********************************************************
208	* Instanciation
209	********************************************************/
210
211	cout << "<" << name << "> Instanciation of _Read_queue" << endl;
212
213	((_Read_queue->in_CLOCK )) ((CLOCK));
214	((_Read_queue->in_NRESET)) ((NRESET));
215
216
217	((_Read_queue-> in_READ_QUEUE_IN_VAL )) ((READ_QUEUE_IN_VAL ));
218	((_Read_queue->out_READ_QUEUE_IN_ACK )) ((READ_QUEUE_IN_ACK ));
219	((_Read_queue-> in_READ_QUEUE_IN_CONTEXT_ID )) ((READ_QUEUE_IN_CONTEXT_ID ));
220	((_Read_queue-> in_READ_QUEUE_IN_FRONT_END_ID )) ((READ_QUEUE_IN_FRONT_END_ID ));
221	((_Read_queue-> in_READ_QUEUE_IN_OOO_ENGINE_ID )) ((READ_QUEUE_IN_OOO_ENGINE_ID ));
222	((_Read_queue-> in_READ_QUEUE_IN_ROB_ID )) ((READ_QUEUE_IN_ROB_ID ));
223	((_Read_queue-> in_READ_QUEUE_IN_OPERATION )) ((READ_QUEUE_IN_OPERATION ));
224	((_Read_queue-> in_READ_QUEUE_IN_TYPE )) ((READ_QUEUE_IN_TYPE ));
225	((_Read_queue-> in_READ_QUEUE_IN_HAS_IMMEDIAT )) ((READ_QUEUE_IN_HAS_IMMEDIAT ));
226	((_Read_queue-> in_READ_QUEUE_IN_IMMEDIAT )) ((READ_QUEUE_IN_IMMEDIAT ));
227	((_Read_queue-> in_READ_QUEUE_IN_READ_RA )) ((READ_QUEUE_IN_READ_RA ));
228	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RA )) ((READ_QUEUE_IN_NUM_REG_RA ));
229	((_Read_queue-> in_READ_QUEUE_IN_READ_RB )) ((READ_QUEUE_IN_READ_RB ));
230	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RB )) ((READ_QUEUE_IN_NUM_REG_RB ));
231	((_Read_queue-> in_READ_QUEUE_IN_READ_RC )) ((READ_QUEUE_IN_READ_RC ));
232	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RC )) ((READ_QUEUE_IN_NUM_REG_RC ));
233	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RD )) ((READ_QUEUE_IN_WRITE_RD ));
234	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RD )) ((READ_QUEUE_IN_NUM_REG_RD ));
235	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RE )) ((READ_QUEUE_IN_WRITE_RE ));
236	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RE )) ((READ_QUEUE_IN_NUM_REG_RE ));
237
238	((_Read_queue->out_READ_QUEUE_OUT_VAL )) ((READ_QUEUE_OUT_VAL ));
239	((_Read_queue-> in_READ_QUEUE_OUT_ACK )) ((READ_QUEUE_OUT_ACK ));
240	((_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID )) ((READ_QUEUE_OUT_CONTEXT_ID ));
241	((_Read_queue->out_READ_QUEUE_OUT_FRONT_END_ID )) ((READ_QUEUE_OUT_FRONT_END_ID ));
242	((_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) ((READ_QUEUE_OUT_OOO_ENGINE_ID ));
243	((_Read_queue->out_READ_QUEUE_OUT_ROB_ID )) ((READ_QUEUE_OUT_ROB_ID ));
244	((_Read_queue->out_READ_QUEUE_OUT_OPERATION )) ((READ_QUEUE_OUT_OPERATION ));
245	((_Read_queue->out_READ_QUEUE_OUT_TYPE )) ((READ_QUEUE_OUT_TYPE ));
246	((_Read_queue->out_READ_QUEUE_OUT_HAS_IMMEDIAT )) ((READ_QUEUE_OUT_HAS_IMMEDIAT ));
247	((_Read_queue->out_READ_QUEUE_OUT_IMMEDIAT )) ((READ_QUEUE_OUT_IMMEDIAT ));
248	((_Read_queue->out_READ_QUEUE_OUT_READ_RA )) ((READ_QUEUE_OUT_READ_RA ));
249	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RA )) ((READ_QUEUE_OUT_NUM_REG_RA ));
250	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA_VAL )) ((READ_QUEUE_OUT_DATA_RA_VAL ));
251	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA )) ((READ_QUEUE_OUT_DATA_RA ));
252	((_Read_queue->out_READ_QUEUE_OUT_READ_RB )) ((READ_QUEUE_OUT_READ_RB ));
253	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RB )) ((READ_QUEUE_OUT_NUM_REG_RB ));
254	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB_VAL )) ((READ_QUEUE_OUT_DATA_RB_VAL ));
255	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB )) ((READ_QUEUE_OUT_DATA_RB ));
256	((_Read_queue->out_READ_QUEUE_OUT_READ_RC )) ((READ_QUEUE_OUT_READ_RC ));
257	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RC )) ((READ_QUEUE_OUT_NUM_REG_RC ));
258	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC_VAL )) ((READ_QUEUE_OUT_DATA_RC_VAL ));
259	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC )) ((READ_QUEUE_OUT_DATA_RC ));
260	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RD )) ((READ_QUEUE_OUT_WRITE_RD ));
261	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RD )) ((READ_QUEUE_OUT_NUM_REG_RD ));
262	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RE )) ((READ_QUEUE_OUT_WRITE_RE ));
263	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RE )) ((READ_QUEUE_OUT_NUM_REG_RE ));
264
265	for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
266	{
267	((_Read_queue->out_GPR_READ_VAL [i])) ((GPR_READ_VAL [i]));
268	((_Read_queue-> in_GPR_READ_ACK [i])) ((GPR_READ_ACK [i]));
269	((_Read_queue->out_GPR_READ_OOO_ENGINE_ID [i])) ((GPR_READ_OOO_ENGINE_ID [i]));
270	((_Read_queue->out_GPR_READ_NUM_REG [i])) ((GPR_READ_NUM_REG [i]));
271	((_Read_queue-> in_GPR_READ_DATA [i])) ((GPR_READ_DATA [i]));
272	((_Read_queue-> in_GPR_READ_DATA_VAL [i])) ((GPR_READ_DATA_VAL [i]));
273	}
274
275	for (uint32_t i=0; i<_param->_nb_spr_read; i++)
276	{
277	((_Read_queue->out_SPR_READ_VAL [i])) ((SPR_READ_VAL [i]));
278	((_Read_queue-> in_SPR_READ_ACK [i])) ((SPR_READ_ACK [i]));
279	((_Read_queue->out_SPR_READ_OOO_ENGINE_ID [i])) ((SPR_READ_OOO_ENGINE_ID [i]));
280	((_Read_queue->out_SPR_READ_NUM_REG [i])) ((SPR_READ_NUM_REG [i]));
281	((_Read_queue-> in_SPR_READ_DATA [i])) ((SPR_READ_DATA [i]));
282	((_Read_queue-> in_SPR_READ_DATA_VAL [i])) ((SPR_READ_DATA_VAL [i]));
283	}
284
285	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
286	{
287	((_Read_queue-> in_GPR_WRITE_VAL [i])) ((GPR_WRITE_VAL [i]));
288	((_Read_queue-> in_GPR_WRITE_OOO_ENGINE_ID [i])) ((GPR_WRITE_OOO_ENGINE_ID [i]));
289	((_Read_queue-> in_GPR_WRITE_NUM_REG [i])) ((GPR_WRITE_NUM_REG [i]));
290	((_Read_queue-> in_GPR_WRITE_DATA [i])) ((GPR_WRITE_DATA [i]));
291	}
292
293	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
294	{
295	((_Read_queue-> in_SPR_WRITE_VAL [i])) ((SPR_WRITE_VAL [i]));
296	((_Read_queue-> in_SPR_WRITE_OOO_ENGINE_ID [i])) ((SPR_WRITE_OOO_ENGINE_ID [i]));
297	((_Read_queue-> in_SPR_WRITE_NUM_REG [i])) ((SPR_WRITE_NUM_REG [i]));
298	((_Read_queue-> in_SPR_WRITE_DATA [i])) ((SPR_WRITE_DATA [i]));
299	}
300
301	cout << "<" << name << "> Start Simulation ............" << endl;
302	Time * _time = new Time();
303
304	/********************************************************
305	* Simulation - Begin
306	********************************************************/
307
308	// Initialisation
309	const uint32_t nb_request = _param->_nb_packet;
310	//const uint32_t seed = 0;
311	const uint32_t seed = static_cast<uint32_t>(time(NULL));
312	srand(seed);
313
314	Tcontext_t _ooo_engine_id [nb_request];
315	Tcontrol_t _read_ra [nb_request];
316	Tgeneral_address_t _num_reg_ra [nb_request];
317	Tcontrol_t _read_rb [nb_request];
318	Tgeneral_address_t _num_reg_rb [nb_request];
319	Tcontrol_t _read_rc [nb_request];
320	Tspecial_address_t _num_reg_rc [nb_request];
321
322	// emulation of registerFile
323	Tcontrol_t _gpr_val [_param->_nb_general_register][_param->_nb_ooo_engine];
324	Tgeneral_data_t _gpr [_param->_nb_general_register][_param->_nb_ooo_engine];
325	Tcontrol_t _spr_val [_param->_nb_special_register][_param->_nb_ooo_engine];
326	Tspecial_data_t _spr [_param->_nb_special_register][_param->_nb_ooo_engine];
327
328	SC_START(0);
329
330	// for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
331	// GPR_WRITE_VAL [i]->write (0);
332	// for (uint32_t i=0; i<_param->_nb_spr_write; i++)
333	// SPR_WRITE_VAL [i]->write (0);
334
335	NRESET->write(0);
336	SC_START(5);
337	NRESET->write(1);
338
339	LABEL("Loop of Test");
340
341	for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
342	{
343	LABEL("Iteration "+toString(iteration));
344	int32_t percent_transaction_queue_in = (rand()%50)+25;
345	int32_t percent_transaction_queue_out = (rand()%50)+25;
346	int32_t percent_registerfile_valid = (rand()%50)+25;
347	int32_t percent_transaction_registerfile = (rand()%74)+25;
348	int32_t percent_transaction_bypass = (rand()%50)+25;
349
350	LABEL("Initialisation");
351
352	for (uint32_t i=0; i<nb_request; i++)
353	{
354	_ooo_engine_id [i] = rand()% _param->_nb_ooo_engine ;
355	_read_ra [i] = rand()% 2 ;
356	_num_reg_ra [i] = rand()% _param->_nb_general_register ;
357	_read_rb [i] = rand()% 2 ;
358	_num_reg_rb [i] = rand()% _param->_nb_general_register ;
359	_read_rc [i] = rand()% 2 ;
360	_num_reg_rc [i] = rand()% _param->_nb_special_register ;
361	}
362
363	// emulation of registerFile
364	for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
365	{
366	for (uint32_t i=0; i<_param->_nb_general_register; i++)
367	{
368	_gpr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
369	_gpr [i][j] = rand()%(1<<_param->_size_general_data);
370	}
371	for (uint32_t i=0; i<_param->_nb_special_register; i++)
372	{
373	_spr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
374	_spr [i][j] = rand()%(1<<_param->_size_special_data);
375	}
376	}
377	// End initialisation .......
378
379	uint32_t request_in = 0;
380	uint32_t request_out = 0;
381
382	while (request_out < nb_request)
383	{
384	if ((request_in < nb_request) and
385	((rand()%100) < percent_transaction_queue_in))
386	{
387	READ_QUEUE_IN_VAL ->write(1);
388	READ_QUEUE_IN_OOO_ENGINE_ID ->write(_ooo_engine_id [request_in]);
389	READ_QUEUE_IN_CONTEXT_ID ->write((2*_ooo_engine_id [request_in])%_param->_nb_context );
390	READ_QUEUE_IN_FRONT_END_ID ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
391	READ_QUEUE_IN_ROB_ID ->write(request_in);
392	READ_QUEUE_IN_OPERATION ->write(0);
393	READ_QUEUE_IN_TYPE ->write(0);
394	READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
395	READ_QUEUE_IN_IMMEDIAT ->write(0);
396	READ_QUEUE_IN_READ_RA ->write(_read_ra [request_in]);
397	READ_QUEUE_IN_NUM_REG_RA ->write(_num_reg_ra [request_in]);
398	READ_QUEUE_IN_READ_RB ->write(_read_rb [request_in]);
399	READ_QUEUE_IN_NUM_REG_RB ->write(_num_reg_rb [request_in]);
400	READ_QUEUE_IN_READ_RC ->write(_read_rc [request_in]);
401	READ_QUEUE_IN_NUM_REG_RC ->write(_num_reg_rc [request_in]);
402	READ_QUEUE_IN_WRITE_RD ->write(0);
403	READ_QUEUE_IN_NUM_REG_RD ->write(0);
404	READ_QUEUE_IN_WRITE_RE ->write(0);
405	READ_QUEUE_IN_NUM_REG_RE ->write(0);
406	}
407	else
408	{
409	READ_QUEUE_IN_VAL ->write(0);
410	}
411
412	READ_QUEUE_OUT_ACK ->write((rand()%100) < percent_transaction_queue_out);
413
414	// RegisterFile access
415	for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
416	{
417	GPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
418	if (GPR_READ_VAL [i]->read())
419	{
420	Tgeneral_address_t num_reg = GPR_READ_NUM_REG [i]->read();
421	Tcontext_t context = GPR_READ_OOO_ENGINE_ID [i]->read();
422
423	GPR_READ_DATA [i]->write(_gpr [num_reg][context]);
424	GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][context]);
425	}
426	}
427	for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
428	{
429	SPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
430
431	if (SPR_READ_VAL [i]->read())
432	{
433	Tspecial_address_t num_reg = SPR_READ_NUM_REG [i]->read();
434	Tcontext_t context = SPR_READ_OOO_ENGINE_ID [i]->read();
435
436	SPR_READ_DATA [i]->write(_spr [num_reg][context]);
437	SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][context]);
438	}
439	}
440
441	// BYPASS
442	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
443	{
444	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
445	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
446	Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
447	Tgeneral_data_t data = rand()%(1<<_param->_size_general_data);
448
449	GPR_WRITE_VAL [i]->write(val);
450	GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
451	GPR_WRITE_NUM_REG [i]->write(num_reg);
452	GPR_WRITE_DATA [i]->write(data);
453
454	if (val)
455	{
456	_gpr [num_reg][ooo_engine] = data;
457	_gpr_val [num_reg][ooo_engine] = 1;
458	}
459	}
460	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
461	{
462	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
463	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
464	Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
465	Tspecial_data_t data = rand()%(1<<_param->_size_special_data);
466
467	SPR_WRITE_VAL [i]->write(val);
468	SPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
469	SPR_WRITE_NUM_REG [i]->write(num_reg);
470	SPR_WRITE_DATA [i]->write(data);
471
472	if (val)
473	{
474	_spr [num_reg][ooo_engine] = data;
475	_spr_val [num_reg][ooo_engine] = 1;
476	}
477	}
478
479	SC_START(0);
480
481	LABEL("Test READ_QUEUE_IN : "+toString(READ_QUEUE_IN_VAL->read())+","+toString(READ_QUEUE_IN_ACK->read()));
482	if ((READ_QUEUE_IN_VAL->read() == 1) and
483	(READ_QUEUE_IN_ACK->read() == 1))
484	{
485	LABEL("Accepted READ_QUEUE_IN ["+toString(request_in)+"]");
486	request_in ++;
487	}
488	LABEL("Test READ_QUEUE_OUT : "+toString(READ_QUEUE_OUT_VAL->read())+","+toString(READ_QUEUE_OUT_ACK->read()));
489	if ((READ_QUEUE_OUT_VAL->read() == 1) and
490	(READ_QUEUE_OUT_ACK->read() == 1))
491	{
492	Tpacket_t rob_id = READ_QUEUE_OUT_ROB_ID->read();
493	Tcontext_t ctxt = _ooo_engine_id [rob_id];
494	LABEL("Accepted READ_QUEUE_OUT ["+toString(rob_id)+"]");
495
496	TEST(uint32_t , rob_id ,request_out);
497
498	request_out ++;
499
500	TEST(Tcontext_t ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
501	TEST(Tcontext_t ,READ_QUEUE_OUT_CONTEXT_ID ->read(),(2*ctxt)%_param->_nb_context );
502	TEST(Tcontext_t ,READ_QUEUE_OUT_FRONT_END_ID ->read(),(3*ctxt)%_param->_nb_front_end);
503
504	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RA ->read(),_read_ra [rob_id]);
505	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RA ->read(),_num_reg_ra [rob_id]);
506	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RA_VAL->read(),not READ_QUEUE_OUT_READ_RA->read() or _gpr_val [_num_reg_ra[rob_id]][ctxt]);
507	if (READ_QUEUE_OUT_READ_RA ->read() and
508	READ_QUEUE_OUT_DATA_RA_VAL->read())
509	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RA ->read(),_gpr [_num_reg_ra[rob_id]][ctxt]);
510	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RB ->read(),_read_rb [rob_id]);
511	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RB ->read(),_num_reg_rb [rob_id]);
512	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RB_VAL->read(),not READ_QUEUE_OUT_READ_RB->read() or _gpr_val [_num_reg_rb[rob_id]][ctxt]);
513	if (READ_QUEUE_OUT_READ_RB ->read() and
514	READ_QUEUE_OUT_DATA_RB_VAL->read())
515	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RB ->read(),_gpr [_num_reg_rb[rob_id]][ctxt]);
516	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RC ->read(),_read_rc [rob_id]);
517	TEST(Tspecial_address_t,READ_QUEUE_OUT_NUM_REG_RC ->read(),_num_reg_rc [rob_id]);
518	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RC_VAL->read(),not READ_QUEUE_OUT_READ_RC->read() or _spr_val [_num_reg_rc[rob_id]][ctxt]);
519	if (READ_QUEUE_OUT_READ_RC ->read() and
520	READ_QUEUE_OUT_DATA_RC_VAL->read())
521	TEST(Tspecial_data_t ,READ_QUEUE_OUT_DATA_RC ->read(),_spr [_num_reg_rc[rob_id]][ctxt]);
522	}
523	SC_START(1);
524	}
525	}
526
527	/********************************************************
528	* Simulation - End
529	********************************************************/
530
531	TEST_OK ("End of Simulation");
532	delete _time;
533	cout << "<" << name << "> ............ Stop Simulation" << endl;
534
535	// delete CLOCK;
536	// delete NRESET;
537
538	// delete READ_QUEUE_IN_VAL ;
539	// delete READ_QUEUE_IN_ACK ;
540	// delete READ_QUEUE_IN_CONTEXT_ID ;
541	// delete READ_QUEUE_IN_FRONT_END_ID;
542	// delete READ_QUEUE_IN_OOO_ENGINE_ID;
543	// delete READ_QUEUE_IN_ROB_ID ;
544	// delete READ_QUEUE_IN_OPERATION ;
545	// delete READ_QUEUE_IN_TYPE ;
546	// delete READ_QUEUE_IN_HAS_IMMEDIAT ;
547	// delete READ_QUEUE_IN_IMMEDIAT ;
548	// delete READ_QUEUE_IN_READ_RA ;
549	// delete READ_QUEUE_IN_NUM_REG_RA ;
550	// delete READ_QUEUE_IN_READ_RB ;
551	// delete READ_QUEUE_IN_NUM_REG_RB ;
552	// delete READ_QUEUE_IN_READ_RC ;
553	// delete READ_QUEUE_IN_NUM_REG_RC ;
554	// delete READ_QUEUE_IN_WRITE_RD ;
555	// delete READ_QUEUE_IN_NUM_REG_RD ;
556	// delete READ_QUEUE_IN_WRITE_RE ;
557	// delete READ_QUEUE_IN_NUM_REG_RE ;
558
559	// delete READ_QUEUE_OUT_VAL ;
560	// delete READ_QUEUE_OUT_ACK ;
561	// delete READ_QUEUE_OUT_CONTEXT_ID ;
562	// delete READ_QUEUE_OUT_FRONT_END_ID;
563	// delete READ_QUEUE_OUT_OOO_ENGINE_ID;
564	// delete READ_QUEUE_OUT_ROB_ID ;
565	// delete READ_QUEUE_OUT_OPERATION ;
566	// delete READ_QUEUE_OUT_TYPE ;
567	// delete READ_QUEUE_OUT_HAS_IMMEDIAT;
568	// delete READ_QUEUE_OUT_IMMEDIAT ;
569	// delete READ_QUEUE_OUT_READ_RA ;
570	// delete READ_QUEUE_OUT_NUM_REG_RA ;
571	// delete READ_QUEUE_OUT_DATA_RA_VAL ;
572	// delete READ_QUEUE_OUT_DATA_RA ;
573	// delete READ_QUEUE_OUT_READ_RB ;
574	// delete READ_QUEUE_OUT_NUM_REG_RB ;
575	// delete READ_QUEUE_OUT_DATA_RB_VAL ;
576	// delete READ_QUEUE_OUT_DATA_RB ;
577	// delete READ_QUEUE_OUT_READ_RC ;
578	// delete READ_QUEUE_OUT_NUM_REG_RC ;
579	// delete READ_QUEUE_OUT_DATA_RC_VAL ;
580	// delete READ_QUEUE_OUT_DATA_RC ;
581	// delete READ_QUEUE_OUT_WRITE_RD ;
582	// delete READ_QUEUE_OUT_NUM_REG_RD ;
583	// delete READ_QUEUE_OUT_WRITE_RE ;
584	// delete READ_QUEUE_OUT_NUM_REG_RE ;
585
586	// delete [] GPR_READ_VAL ;
587	// delete [] GPR_READ_ACK ;
588	// delete [] GPR_READ_NUM_REG ;
589	// delete [] GPR_READ_DATA ;
590	// delete [] GPR_READ_DATA_VAL;
591	// delete [] GPR_READ_OOO_ENGINE_ID ;
592
593	// delete [] SPR_READ_VAL ;
594	// delete [] SPR_READ_ACK ;
595	// delete [] SPR_READ_NUM_REG ;
596	// delete [] SPR_READ_DATA ;
597	// delete [] SPR_READ_DATA_VAL;
598	// delete [] SPR_READ_OOO_ENGINE_ID ;
599
600	// delete [] GPR_WRITE_VAL ;
601	// delete [] GPR_WRITE_OOO_ENGINE_ID ;
602	// delete [] GPR_WRITE_NUM_REG ;
603	// delete [] GPR_WRITE_DATA ;
604
605	// delete [] SPR_WRITE_VAL ;
606	// delete [] SPR_WRITE_OOO_ENGINE_ID ;
607	// delete [] SPR_WRITE_NUM_REG ;
608	// delete [] SPR_WRITE_DATA ;
609	#endif
610
611	delete _Read_queue;
612
613	#ifdef STATISTICS
614	delete _parameters_statistics;
615	#endif
616	}

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

Download in other formats: