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 @ 68

Last change on this file since 68 was 68, checked in by rosiere, 17 years ago
read_queue : systemC et vhdl ok ! queue : quelques petits modif pour avoir une queue de taille 1 nettoyage des fichiers mkf
File size: 35.4 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	((_Read_queue-> in_READ_QUEUE_IN_VAL )) ((READ_QUEUE_IN_VAL ));
217	((_Read_queue->out_READ_QUEUE_IN_ACK )) ((READ_QUEUE_IN_ACK ));
218	if(_param->_have_port_context_id )
219	((_Read_queue-> in_READ_QUEUE_IN_CONTEXT_ID )) ((READ_QUEUE_IN_CONTEXT_ID ));
220	if(_param->_have_port_front_end_id )
221	((_Read_queue-> in_READ_QUEUE_IN_FRONT_END_ID )) ((READ_QUEUE_IN_FRONT_END_ID ));
222	if(_param->_have_port_ooo_engine_id)
223	((_Read_queue-> in_READ_QUEUE_IN_OOO_ENGINE_ID )) ((READ_QUEUE_IN_OOO_ENGINE_ID ));
224	if(_param->_have_port_rob_id )
225	((_Read_queue-> in_READ_QUEUE_IN_ROB_ID )) ((READ_QUEUE_IN_ROB_ID ));
226	((_Read_queue-> in_READ_QUEUE_IN_OPERATION )) ((READ_QUEUE_IN_OPERATION ));
227	((_Read_queue-> in_READ_QUEUE_IN_TYPE )) ((READ_QUEUE_IN_TYPE ));
228	((_Read_queue-> in_READ_QUEUE_IN_HAS_IMMEDIAT )) ((READ_QUEUE_IN_HAS_IMMEDIAT ));
229	((_Read_queue-> in_READ_QUEUE_IN_IMMEDIAT )) ((READ_QUEUE_IN_IMMEDIAT ));
230	((_Read_queue-> in_READ_QUEUE_IN_READ_RA )) ((READ_QUEUE_IN_READ_RA ));
231	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RA )) ((READ_QUEUE_IN_NUM_REG_RA ));
232	((_Read_queue-> in_READ_QUEUE_IN_READ_RB )) ((READ_QUEUE_IN_READ_RB ));
233	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RB )) ((READ_QUEUE_IN_NUM_REG_RB ));
234	((_Read_queue-> in_READ_QUEUE_IN_READ_RC )) ((READ_QUEUE_IN_READ_RC ));
235	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RC )) ((READ_QUEUE_IN_NUM_REG_RC ));
236	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RD )) ((READ_QUEUE_IN_WRITE_RD ));
237	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RD )) ((READ_QUEUE_IN_NUM_REG_RD ));
238	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RE )) ((READ_QUEUE_IN_WRITE_RE ));
239	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RE )) ((READ_QUEUE_IN_NUM_REG_RE ));
240
241	((_Read_queue->out_READ_QUEUE_OUT_VAL )) ((READ_QUEUE_OUT_VAL ));
242	((_Read_queue-> in_READ_QUEUE_OUT_ACK )) ((READ_QUEUE_OUT_ACK ));
243	if(_param->_have_port_context_id )
244	((_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID )) ((READ_QUEUE_OUT_CONTEXT_ID ));
245	if(_param->_have_port_front_end_id )
246	((_Read_queue->out_READ_QUEUE_OUT_FRONT_END_ID )) ((READ_QUEUE_OUT_FRONT_END_ID ));
247	if(_param->_have_port_ooo_engine_id)
248	((_Read_queue->out_READ_QUEUE_OUT_OOO_ENGINE_ID )) ((READ_QUEUE_OUT_OOO_ENGINE_ID ));
249	if(_param->_have_port_rob_id )
250	((_Read_queue->out_READ_QUEUE_OUT_ROB_ID )) ((READ_QUEUE_OUT_ROB_ID ));
251	((_Read_queue->out_READ_QUEUE_OUT_OPERATION )) ((READ_QUEUE_OUT_OPERATION ));
252	((_Read_queue->out_READ_QUEUE_OUT_TYPE )) ((READ_QUEUE_OUT_TYPE ));
253	((_Read_queue->out_READ_QUEUE_OUT_HAS_IMMEDIAT )) ((READ_QUEUE_OUT_HAS_IMMEDIAT ));
254	((_Read_queue->out_READ_QUEUE_OUT_IMMEDIAT )) ((READ_QUEUE_OUT_IMMEDIAT ));
255	((_Read_queue->out_READ_QUEUE_OUT_READ_RA )) ((READ_QUEUE_OUT_READ_RA ));
256	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RA )) ((READ_QUEUE_OUT_NUM_REG_RA ));
257	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA_VAL )) ((READ_QUEUE_OUT_DATA_RA_VAL ));
258	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA )) ((READ_QUEUE_OUT_DATA_RA ));
259	((_Read_queue->out_READ_QUEUE_OUT_READ_RB )) ((READ_QUEUE_OUT_READ_RB ));
260	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RB )) ((READ_QUEUE_OUT_NUM_REG_RB ));
261	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB_VAL )) ((READ_QUEUE_OUT_DATA_RB_VAL ));
262	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB )) ((READ_QUEUE_OUT_DATA_RB ));
263	((_Read_queue->out_READ_QUEUE_OUT_READ_RC )) ((READ_QUEUE_OUT_READ_RC ));
264	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RC )) ((READ_QUEUE_OUT_NUM_REG_RC ));
265	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC_VAL )) ((READ_QUEUE_OUT_DATA_RC_VAL ));
266	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC )) ((READ_QUEUE_OUT_DATA_RC ));
267	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RD )) ((READ_QUEUE_OUT_WRITE_RD ));
268	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RD )) ((READ_QUEUE_OUT_NUM_REG_RD ));
269	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RE )) ((READ_QUEUE_OUT_WRITE_RE ));
270	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RE )) ((READ_QUEUE_OUT_NUM_REG_RE ));
271
272	for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
273	{
274	((_Read_queue->out_GPR_READ_VAL [i])) ((GPR_READ_VAL [i]));
275	((_Read_queue-> in_GPR_READ_ACK [i])) ((GPR_READ_ACK [i]));
276	if(_param->_have_port_ooo_engine_id)
277	((_Read_queue->out_GPR_READ_OOO_ENGINE_ID [i])) ((GPR_READ_OOO_ENGINE_ID [i]));
278	((_Read_queue->out_GPR_READ_NUM_REG [i])) ((GPR_READ_NUM_REG [i]));
279	((_Read_queue-> in_GPR_READ_DATA [i])) ((GPR_READ_DATA [i]));
280	((_Read_queue-> in_GPR_READ_DATA_VAL [i])) ((GPR_READ_DATA_VAL [i]));
281	}
282
283	for (uint32_t i=0; i<_param->_nb_spr_read; i++)
284	{
285	((_Read_queue->out_SPR_READ_VAL [i])) ((SPR_READ_VAL [i]));
286	((_Read_queue-> in_SPR_READ_ACK [i])) ((SPR_READ_ACK [i]));
287	if(_param->_have_port_ooo_engine_id)
288	((_Read_queue->out_SPR_READ_OOO_ENGINE_ID [i])) ((SPR_READ_OOO_ENGINE_ID [i]));
289	((_Read_queue->out_SPR_READ_NUM_REG [i])) ((SPR_READ_NUM_REG [i]));
290	((_Read_queue-> in_SPR_READ_DATA [i])) ((SPR_READ_DATA [i]));
291	((_Read_queue-> in_SPR_READ_DATA_VAL [i])) ((SPR_READ_DATA_VAL [i]));
292	}
293
294	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
295	{
296	((_Read_queue-> in_GPR_WRITE_VAL [i])) ((GPR_WRITE_VAL [i]));
297	if(_param->_have_port_ooo_engine_id)
298	((_Read_queue-> in_GPR_WRITE_OOO_ENGINE_ID [i])) ((GPR_WRITE_OOO_ENGINE_ID [i]));
299	((_Read_queue-> in_GPR_WRITE_NUM_REG [i])) ((GPR_WRITE_NUM_REG [i]));
300	((_Read_queue-> in_GPR_WRITE_DATA [i])) ((GPR_WRITE_DATA [i]));
301	}
302
303	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
304	{
305	((_Read_queue-> in_SPR_WRITE_VAL [i])) ((SPR_WRITE_VAL [i]));
306	if(_param->_have_port_ooo_engine_id)
307	((_Read_queue-> in_SPR_WRITE_OOO_ENGINE_ID [i])) ((SPR_WRITE_OOO_ENGINE_ID [i]));
308	((_Read_queue-> in_SPR_WRITE_NUM_REG [i])) ((SPR_WRITE_NUM_REG [i]));
309	((_Read_queue-> in_SPR_WRITE_DATA [i])) ((SPR_WRITE_DATA [i]));
310	}
311
312	cout << "<" << name << "> Start Simulation ............" << endl;
313	Time * _time = new Time();
314
315	/********************************************************
316	* Simulation - Begin
317	********************************************************/
318
319	// Initialisation
320	const uint32_t nb_request = _param->_nb_packet;
321	// const uint32_t seed = 0;
322	const uint32_t seed = static_cast<uint32_t>(time(NULL));
323	srand(seed);
324
325	Tcontext_t _ooo_engine_id [nb_request];
326	Tcontrol_t _read_ra [nb_request];
327	Tgeneral_address_t _num_reg_ra [nb_request];
328	Tcontrol_t _read_rb [nb_request];
329	Tgeneral_address_t _num_reg_rb [nb_request];
330	Tcontrol_t _read_rc [nb_request];
331	Tspecial_address_t _num_reg_rc [nb_request];
332
333	// emulation of registerFile
334	Tcontrol_t _gpr_val [_param->_nb_general_register][_param->_nb_ooo_engine];
335	Tgeneral_data_t _gpr [_param->_nb_general_register][_param->_nb_ooo_engine];
336	Tcontrol_t _spr_val [_param->_nb_special_register][_param->_nb_ooo_engine];
337	Tspecial_data_t _spr [_param->_nb_special_register][_param->_nb_ooo_engine];
338
339	SC_START(0);
340
341	// for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
342	// GPR_WRITE_VAL [i]->write (0);
343	// for (uint32_t i=0; i<_param->_nb_spr_write; i++)
344	// SPR_WRITE_VAL [i]->write (0);
345
346	NRESET->write(0);
347	SC_START(5);
348	NRESET->write(1);
349
350	LABEL("Loop of Test");
351
352	for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
353	{
354	LABEL("Iteration "+toString(iteration));
355	int32_t percent_transaction_queue_in = (rand()%45)+30;
356	int32_t percent_transaction_queue_out = (rand()%45)+30;
357	int32_t percent_registerfile_valid = (rand()%45)+30;
358	int32_t percent_transaction_registerfile = (rand()%45)+30;
359	int32_t percent_transaction_bypass = (rand()%45)+30;
360	int32_t percent_must_read_reg = (rand()%45)+30;
361
362	LABEL("Initialisation");
363
364	for (uint32_t i=0; i<nb_request; i++)
365	{
366	_ooo_engine_id [i] = rand()% _param->_nb_ooo_engine ;
367	_read_ra [i] = (rand()%100)<percent_must_read_reg;
368	_num_reg_ra [i] = rand()% _param->_nb_general_register ;
369	_read_rb [i] = (rand()%100)<percent_must_read_reg;
370	_num_reg_rb [i] = rand()% _param->_nb_general_register ;
371	_read_rc [i] = (rand()%100)<percent_must_read_reg;
372	_num_reg_rc [i] = rand()% _param->_nb_special_register ;
373	}
374
375	// emulation of registerFile
376	for (uint32_t j=0; j<_param->_nb_ooo_engine; j++)
377	{
378	for (uint32_t i=0; i<_param->_nb_general_register; i++)
379	{
380	_gpr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
381	_gpr [i][j] = rand()%(1<<_param->_size_general_data);
382	}
383	for (uint32_t i=0; i<_param->_nb_special_register; i++)
384	{
385	_spr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
386	_spr [i][j] = rand()%(1<<_param->_size_special_data);
387	}
388	}
389	// End initialisation .......
390
391	uint32_t request_in = 0;
392	uint32_t request_out = 0;
393
394	while (request_out < nb_request)
395	{
396	if ((request_in < nb_request) and
397	((rand()%100) < percent_transaction_queue_in))
398	{
399	READ_QUEUE_IN_VAL ->write(1);
400	if(_param->_have_port_ooo_engine_id)
401	READ_QUEUE_IN_OOO_ENGINE_ID ->write(_ooo_engine_id [request_in]);
402	if(_param->_have_port_context_id )
403	READ_QUEUE_IN_CONTEXT_ID ->write((2*_ooo_engine_id [request_in])%_param->_nb_context );
404	if(_param->_have_port_front_end_id )
405	READ_QUEUE_IN_FRONT_END_ID ->write((3*_ooo_engine_id [request_in])%_param->_nb_front_end);
406	if(_param->_have_port_rob_id )
407	READ_QUEUE_IN_ROB_ID ->write(request_in);
408	READ_QUEUE_IN_OPERATION ->write(0);
409	READ_QUEUE_IN_TYPE ->write(0);
410	READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
411	READ_QUEUE_IN_IMMEDIAT ->write(0);
412	READ_QUEUE_IN_READ_RA ->write(_read_ra [request_in]);
413	READ_QUEUE_IN_NUM_REG_RA ->write(_num_reg_ra [request_in]);
414	READ_QUEUE_IN_READ_RB ->write(_read_rb [request_in]);
415	READ_QUEUE_IN_NUM_REG_RB ->write(_num_reg_rb [request_in]);
416	READ_QUEUE_IN_READ_RC ->write(_read_rc [request_in]);
417	READ_QUEUE_IN_NUM_REG_RC ->write(_num_reg_rc [request_in]);
418	READ_QUEUE_IN_WRITE_RD ->write(0);
419	READ_QUEUE_IN_NUM_REG_RD ->write(0);
420	READ_QUEUE_IN_WRITE_RE ->write(0);
421	READ_QUEUE_IN_NUM_REG_RE ->write(0);
422	}
423	else
424	{
425	READ_QUEUE_IN_VAL ->write(0);
426	}
427
428	READ_QUEUE_OUT_ACK ->write((rand()%100) < percent_transaction_queue_out);
429
430	// RegisterFile access
431	for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
432	{
433	GPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
434	if (GPR_READ_VAL [i]->read())
435	{
436	Tgeneral_address_t num_reg = GPR_READ_NUM_REG [i]->read();
437	Tcontext_t ooo_engine;
438	if(_param->_have_port_ooo_engine_id)
439	ooo_engine = GPR_READ_OOO_ENGINE_ID [i]->read();
440	else
441	ooo_engine = 0;
442
443	GPR_READ_DATA [i]->write(_gpr [num_reg][ooo_engine]);
444	GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][ooo_engine]);
445	}
446	}
447	for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
448	{
449	SPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
450
451	if (SPR_READ_VAL [i]->read())
452	{
453	Tspecial_address_t num_reg = SPR_READ_NUM_REG [i]->read();
454	Tcontext_t ooo_engine;
455	if(_param->_have_port_ooo_engine_id)
456	ooo_engine = SPR_READ_OOO_ENGINE_ID [i]->read();
457	else
458	ooo_engine = 0;
459
460	SPR_READ_DATA [i]->write(_spr [num_reg][ooo_engine]);
461	SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][ooo_engine]);
462	}
463	}
464
465	// BYPASS
466	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
467	{
468	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
469	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
470	Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
471	Tgeneral_data_t data = rand()%(1<<_param->_size_general_data);
472
473	GPR_WRITE_VAL [i]->write(val);
474	if(_param->_have_port_ooo_engine_id)
475	GPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
476	GPR_WRITE_NUM_REG [i]->write(num_reg);
477	GPR_WRITE_DATA [i]->write(data);
478
479	if (val)
480	{
481	_gpr [num_reg][ooo_engine] = data;
482	_gpr_val [num_reg][ooo_engine] = 1;
483	}
484	}
485	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
486	{
487	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
488	Tcontext_t ooo_engine = rand()% _param->_nb_ooo_engine;
489	Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
490	Tspecial_data_t data = rand()%(1<<_param->_size_special_data);
491
492	SPR_WRITE_VAL [i]->write(val);
493	if(_param->_have_port_ooo_engine_id)
494	SPR_WRITE_OOO_ENGINE_ID [i]->write(ooo_engine);
495	SPR_WRITE_NUM_REG [i]->write(num_reg);
496	SPR_WRITE_DATA [i]->write(data);
497
498	if (val)
499	{
500	_spr [num_reg][ooo_engine] = data;
501	_spr_val [num_reg][ooo_engine] = 1;
502	}
503	}
504
505	SC_START(0);
506
507	LABEL("Test READ_QUEUE_IN : "+toString(READ_QUEUE_IN_VAL->read())+","+toString(READ_QUEUE_IN_ACK->read()));
508	if ((READ_QUEUE_IN_VAL->read() == 1) and
509	(READ_QUEUE_IN_ACK->read() == 1))
510	{
511	LABEL("Accepted READ_QUEUE_IN ["+toString(request_in)+"]");
512	request_in ++;
513	}
514	LABEL("Test READ_QUEUE_OUT : "+toString(READ_QUEUE_OUT_VAL->read())+","+toString(READ_QUEUE_OUT_ACK->read()));
515	if ((READ_QUEUE_OUT_VAL->read() == 1) and
516	(READ_QUEUE_OUT_ACK->read() == 1))
517	{
518	Tpacket_t rob_id;
519	if(_param->_have_port_rob_id )
520	rob_id = READ_QUEUE_OUT_ROB_ID->read();
521	else
522	rob_id = 0;
523	Tcontext_t ctxt = _ooo_engine_id [rob_id];
524	LABEL("Accepted READ_QUEUE_OUT ["+toString(rob_id)+"]");
525
526	TEST(uint32_t , rob_id ,request_out);
527
528	request_out ++;
529
530	if(_param->_have_port_ooo_engine_id)
531	TEST(Tcontext_t ,READ_QUEUE_OUT_OOO_ENGINE_ID ->read(),ctxt);
532	if(_param->_have_port_context_id )
533	TEST(Tcontext_t ,READ_QUEUE_OUT_CONTEXT_ID ->read(),(2*ctxt)%_param->_nb_context );
534	if(_param->_have_port_front_end_id )
535	TEST(Tcontext_t ,READ_QUEUE_OUT_FRONT_END_ID ->read(),(3*ctxt)%_param->_nb_front_end);
536
537	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RA ->read(),_read_ra [rob_id]);
538	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RA ->read(),_num_reg_ra [rob_id]);
539	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]);
540	if (READ_QUEUE_OUT_READ_RA ->read() and
541	READ_QUEUE_OUT_DATA_RA_VAL->read())
542	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RA ->read(),_gpr [_num_reg_ra[rob_id]][ctxt]);
543	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RB ->read(),_read_rb [rob_id]);
544	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RB ->read(),_num_reg_rb [rob_id]);
545	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]);
546	if (READ_QUEUE_OUT_READ_RB ->read() and
547	READ_QUEUE_OUT_DATA_RB_VAL->read())
548	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RB ->read(),_gpr [_num_reg_rb[rob_id]][ctxt]);
549	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RC ->read(),_read_rc [rob_id]);
550	TEST(Tspecial_address_t,READ_QUEUE_OUT_NUM_REG_RC ->read(),_num_reg_rc [rob_id]);
551	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]);
552	if (READ_QUEUE_OUT_READ_RC ->read() and
553	READ_QUEUE_OUT_DATA_RC_VAL->read())
554	TEST(Tspecial_data_t ,READ_QUEUE_OUT_DATA_RC ->read(),_spr [_num_reg_rc[rob_id]][ctxt]);
555	}
556	SC_START(1);
557	}
558	}
559
560	/********************************************************
561	* Simulation - End
562	********************************************************/
563
564	TEST_OK ("End of Simulation");
565	delete _time;
566	cout << "<" << name << "> ............ Stop Simulation" << endl;
567
568	delete CLOCK;
569	delete NRESET;
570
571	delete READ_QUEUE_IN_VAL ;
572	delete READ_QUEUE_IN_ACK ;
573	if(_param->_have_port_context_id )
574	delete READ_QUEUE_IN_CONTEXT_ID ;
575	if(_param->_have_port_front_end_id )
576	delete READ_QUEUE_IN_FRONT_END_ID;
577	if(_param->_have_port_ooo_engine_id )
578	delete READ_QUEUE_IN_OOO_ENGINE_ID;
579	if(_param->_have_port_rob_id )
580	delete READ_QUEUE_IN_ROB_ID ;
581	delete READ_QUEUE_IN_OPERATION ;
582	delete READ_QUEUE_IN_TYPE ;
583	delete READ_QUEUE_IN_HAS_IMMEDIAT ;
584	delete READ_QUEUE_IN_IMMEDIAT ;
585	delete READ_QUEUE_IN_READ_RA ;
586	delete READ_QUEUE_IN_NUM_REG_RA ;
587	delete READ_QUEUE_IN_READ_RB ;
588	delete READ_QUEUE_IN_NUM_REG_RB ;
589	delete READ_QUEUE_IN_READ_RC ;
590	delete READ_QUEUE_IN_NUM_REG_RC ;
591	delete READ_QUEUE_IN_WRITE_RD ;
592	delete READ_QUEUE_IN_NUM_REG_RD ;
593	delete READ_QUEUE_IN_WRITE_RE ;
594	delete READ_QUEUE_IN_NUM_REG_RE ;
595
596	delete READ_QUEUE_OUT_VAL ;
597	delete READ_QUEUE_OUT_ACK ;
598	if(_param->_have_port_context_id )
599	delete READ_QUEUE_OUT_CONTEXT_ID ;
600	if(_param->_have_port_front_end_id )
601	delete READ_QUEUE_OUT_FRONT_END_ID;
602	if(_param->_have_port_ooo_engine_id )
603	delete READ_QUEUE_OUT_OOO_ENGINE_ID;
604	if(_param->_have_port_rob_id )
605	delete READ_QUEUE_OUT_ROB_ID ;
606	delete READ_QUEUE_OUT_OPERATION ;
607	delete READ_QUEUE_OUT_TYPE ;
608	delete READ_QUEUE_OUT_HAS_IMMEDIAT;
609	delete READ_QUEUE_OUT_IMMEDIAT ;
610	delete READ_QUEUE_OUT_READ_RA ;
611	delete READ_QUEUE_OUT_NUM_REG_RA ;
612	delete READ_QUEUE_OUT_DATA_RA_VAL ;
613	delete READ_QUEUE_OUT_DATA_RA ;
614	delete READ_QUEUE_OUT_READ_RB ;
615	delete READ_QUEUE_OUT_NUM_REG_RB ;
616	delete READ_QUEUE_OUT_DATA_RB_VAL ;
617	delete READ_QUEUE_OUT_DATA_RB ;
618	delete READ_QUEUE_OUT_READ_RC ;
619	delete READ_QUEUE_OUT_NUM_REG_RC ;
620	delete READ_QUEUE_OUT_DATA_RC_VAL ;
621	delete READ_QUEUE_OUT_DATA_RC ;
622	delete READ_QUEUE_OUT_WRITE_RD ;
623	delete READ_QUEUE_OUT_NUM_REG_RD ;
624	delete READ_QUEUE_OUT_WRITE_RE ;
625	delete READ_QUEUE_OUT_NUM_REG_RE ;
626
627	delete [] GPR_READ_VAL ;
628	delete [] GPR_READ_ACK ;
629	delete [] GPR_READ_NUM_REG ;
630	delete [] GPR_READ_DATA ;
631	delete [] GPR_READ_DATA_VAL;
632	if(_param->_have_port_ooo_engine_id )
633	delete [] GPR_READ_OOO_ENGINE_ID ;
634
635	delete [] SPR_READ_VAL ;
636	delete [] SPR_READ_ACK ;
637	delete [] SPR_READ_NUM_REG ;
638	delete [] SPR_READ_DATA ;
639	delete [] SPR_READ_DATA_VAL;
640	if(_param->_have_port_ooo_engine_id )
641	delete [] SPR_READ_OOO_ENGINE_ID ;
642
643	delete [] GPR_WRITE_VAL ;
644	if(_param->_have_port_ooo_engine_id )
645	delete [] GPR_WRITE_OOO_ENGINE_ID ;
646	delete [] GPR_WRITE_NUM_REG ;
647	delete [] GPR_WRITE_DATA ;
648
649	delete [] SPR_WRITE_VAL ;
650	if(_param->_have_port_ooo_engine_id )
651	delete [] SPR_WRITE_OOO_ENGINE_ID ;
652	delete [] SPR_WRITE_NUM_REG ;
653	delete [] SPR_WRITE_DATA ;
654	#endif
655
656	delete _Read_queue;
657
658	#ifdef STATISTICS
659	delete _parameters_statistics;
660	#endif
661	}

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

Download in other formats: