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

Last change on this file since 55 was 55, checked in by rosiere, 17 years ago
Ajout SystemC read_queue et reservation_station Ajout port au bloc registerfile_monolithic (à ajouter également au bloc registerfile et registerfile_multi_banked) Modif param : passage de pointeur (attention, tous les composants n'ont pas été tous modifier)
File size: 32.2 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 "Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Read_unit/Read_unit/Read_queue/include/Types.h"
11	#include "Common/include/Test.h"
12
13	#define NB_ITERATION 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<Tpacket_t > * READ_QUEUE_IN_PACKET_ID = new sc_signal<Tpacket_t > ("READ_QUEUE_IN_PACKET_ID ");
73	sc_signal<Toperation_t > * READ_QUEUE_IN_OPERATION = new sc_signal<Toperation_t > ("READ_QUEUE_IN_OPERATION ");
74	sc_signal<Ttype_t > * READ_QUEUE_IN_TYPE = new sc_signal<Ttype_t > ("READ_QUEUE_IN_TYPE ");
75	sc_signal<Tcontrol_t > * READ_QUEUE_IN_HAS_IMMEDIAT = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_HAS_IMMEDIAT");
76	sc_signal<Tgeneral_data_t > * READ_QUEUE_IN_IMMEDIAT = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_IN_IMMEDIAT ");
77	sc_signal<Tcontrol_t > * READ_QUEUE_IN_READ_RA = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_READ_RA ");
78	sc_signal<Tgeneral_address_t > * READ_QUEUE_IN_NUM_REG_RA = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_IN_NUM_REG_RA ");
79	sc_signal<Tcontrol_t > * READ_QUEUE_IN_READ_RB = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_READ_RB ");
80	sc_signal<Tgeneral_address_t > * READ_QUEUE_IN_NUM_REG_RB = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_IN_NUM_REG_RB ");
81	sc_signal<Tcontrol_t > * READ_QUEUE_IN_READ_RC = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_READ_RC ");
82	sc_signal<Tspecial_address_t > * READ_QUEUE_IN_NUM_REG_RC = new sc_signal<Tspecial_address_t > ("READ_QUEUE_IN_NUM_REG_RC ");
83	sc_signal<Tcontrol_t > * READ_QUEUE_IN_WRITE_RD = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_WRITE_RD ");
84	sc_signal<Tgeneral_address_t > * READ_QUEUE_IN_NUM_REG_RD = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_IN_NUM_REG_RD ");
85	sc_signal<Tcontrol_t > * READ_QUEUE_IN_WRITE_RE = new sc_signal<Tcontrol_t > ("READ_QUEUE_IN_WRITE_RE ");
86	sc_signal<Tspecial_address_t > * READ_QUEUE_IN_NUM_REG_RE = new sc_signal<Tspecial_address_t > ("READ_QUEUE_IN_NUM_REG_RE ");
87
88	// ~~~~~[ Interface "read_queue_out" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
89
90	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_VAL ");
91	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_ACK = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_ACK ");
92	sc_signal<Tcontext_t > * READ_QUEUE_OUT_CONTEXT_ID = new sc_signal<Tcontext_t > ("READ_QUEUE_OUT_CONTEXT_ID ");
93	sc_signal<Tpacket_t > * READ_QUEUE_OUT_PACKET_ID = new sc_signal<Tpacket_t > ("READ_QUEUE_OUT_PACKET_ID ");
94	sc_signal<Toperation_t > * READ_QUEUE_OUT_OPERATION = new sc_signal<Toperation_t > ("READ_QUEUE_OUT_OPERATION ");
95	sc_signal<Ttype_t > * READ_QUEUE_OUT_TYPE = new sc_signal<Ttype_t > ("READ_QUEUE_OUT_TYPE ");
96	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_HAS_IMMEDIAT= new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_HAS_IMMEDIAT");
97	sc_signal<Tgeneral_data_t > * READ_QUEUE_OUT_IMMEDIAT = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_OUT_IMMEDIAT ");
98	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_READ_RA = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_READ_RA ");
99	sc_signal<Tgeneral_address_t > * READ_QUEUE_OUT_NUM_REG_RA = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_OUT_NUM_REG_RA ");
100	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_DATA_RA_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_DATA_RA_VAL ");
101	sc_signal<Tgeneral_data_t > * READ_QUEUE_OUT_DATA_RA = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_OUT_DATA_RA ");
102	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_READ_RB = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_READ_RB ");
103	sc_signal<Tgeneral_address_t > * READ_QUEUE_OUT_NUM_REG_RB = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_OUT_NUM_REG_RB ");
104	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_DATA_RB_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_DATA_RB_VAL ");
105	sc_signal<Tgeneral_data_t > * READ_QUEUE_OUT_DATA_RB = new sc_signal<Tgeneral_data_t > ("READ_QUEUE_OUT_DATA_RB ");
106	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_READ_RC = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_READ_RC ");
107	sc_signal<Tspecial_address_t > * READ_QUEUE_OUT_NUM_REG_RC = new sc_signal<Tspecial_address_t > ("READ_QUEUE_OUT_NUM_REG_RC ");
108	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_DATA_RC_VAL = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_DATA_RC_VAL ");
109	sc_signal<Tspecial_data_t > * READ_QUEUE_OUT_DATA_RC = new sc_signal<Tspecial_data_t > ("READ_QUEUE_OUT_DATA_RC ");
110	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_WRITE_RD = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_WRITE_RD ");
111	sc_signal<Tgeneral_address_t > * READ_QUEUE_OUT_NUM_REG_RD = new sc_signal<Tgeneral_address_t > ("READ_QUEUE_OUT_NUM_REG_RD ");
112	sc_signal<Tcontrol_t > * READ_QUEUE_OUT_WRITE_RE = new sc_signal<Tcontrol_t > ("READ_QUEUE_OUT_WRITE_RE ");
113	sc_signal<Tspecial_address_t > * READ_QUEUE_OUT_NUM_REG_RE = new sc_signal<Tspecial_address_t > ("READ_QUEUE_OUT_NUM_REG_RE ");
114
115	// ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
116
117	sc_signal<Tcontrol_t > ** GPR_READ_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
118	sc_signal<Tcontrol_t > ** GPR_READ_ACK = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
119	sc_signal<Tcontext_t > ** GPR_READ_CONTEXT_ID = new sc_signal<Tcontext_t > * [_param->_nb_gpr_read];
120	sc_signal<Tgeneral_address_t > ** GPR_READ_NUM_REG = new sc_signal<Tgeneral_address_t > * [_param->_nb_gpr_read];
121	sc_signal<Tgeneral_data_t > ** GPR_READ_DATA = new sc_signal<Tgeneral_data_t > * [_param->_nb_gpr_read];
122	sc_signal<Tcontrol_t > ** GPR_READ_DATA_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_read];
123
124	for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
125	{
126	rename = "GPR_READ_"+toString(i)+"_VAL";
127	GPR_READ_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
128	rename = "GPR_READ_"+toString(i)+"_ACK";
129	GPR_READ_ACK [i] = new sc_signal<Tcontrol_t > (rename.c_str());
130	rename = "GPR_READ_"+toString(i)+"_CONTEXT_ID";
131	GPR_READ_CONTEXT_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
132	rename = "GPR_READ_"+toString(i)+"_NUM_REG";
133	GPR_READ_NUM_REG [i] = new sc_signal<Tgeneral_address_t > (rename.c_str());
134	rename = "GPR_READ_"+toString(i)+"_DATA";
135	GPR_READ_DATA [i] = new sc_signal<Tgeneral_data_t > (rename.c_str());
136	rename = "GPR_READ_"+toString(i)+"_DATA_VAL";
137	GPR_READ_DATA_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
138	}
139
140	// ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
141
142	sc_signal<Tcontrol_t > ** SPR_READ_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
143	sc_signal<Tcontrol_t > ** SPR_READ_ACK = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
144	sc_signal<Tcontext_t > ** SPR_READ_CONTEXT_ID = new sc_signal<Tcontext_t > * [_param->_nb_spr_read];
145	sc_signal<Tspecial_address_t > ** SPR_READ_NUM_REG = new sc_signal<Tspecial_address_t > * [_param->_nb_spr_read];
146	sc_signal<Tspecial_data_t > ** SPR_READ_DATA = new sc_signal<Tspecial_data_t > * [_param->_nb_spr_read];
147	sc_signal<Tcontrol_t > ** SPR_READ_DATA_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_read];
148
149	for (uint32_t i=0; i<_param->_nb_spr_read; i++)
150	{
151	rename = "SPR_READ_"+toString(i)+"_VAL";
152	SPR_READ_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
153	rename = "SPR_READ_"+toString(i)+"_ACK";
154	SPR_READ_ACK [i] = new sc_signal<Tcontrol_t > (rename.c_str());
155	rename = "SPR_READ_"+toString(i)+"_CONTEXT_ID";
156	SPR_READ_CONTEXT_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
157	rename = "SPR_READ_"+toString(i)+"_NUM_REG";
158	SPR_READ_NUM_REG [i] = new sc_signal<Tspecial_address_t > (rename.c_str());
159	rename = "SPR_READ_"+toString(i)+"_DATA";
160	SPR_READ_DATA [i] = new sc_signal<Tspecial_data_t > (rename.c_str());
161	rename = "SPR_READ_"+toString(i)+"_DATA_VAL";
162	SPR_READ_DATA_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
163	}
164
165	// ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
166
167	sc_signal<Tcontrol_t > ** GPR_WRITE_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_gpr_write];
168	sc_signal<Tcontext_t > ** GPR_WRITE_CONTEXT_ID = new sc_signal<Tcontext_t > * [_param->_nb_gpr_write];
169	sc_signal<Tgeneral_address_t > ** GPR_WRITE_NUM_REG = new sc_signal<Tgeneral_address_t > * [_param->_nb_gpr_write];
170	sc_signal<Tgeneral_data_t > ** GPR_WRITE_DATA = new sc_signal<Tgeneral_data_t > * [_param->_nb_gpr_write];
171
172	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
173	{
174	rename = "GPR_WRITE_"+toString(i)+"_VAL" ;
175	GPR_WRITE_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
176	rename = "GPR_WRITE_"+toString(i)+"_CONTEXT_ID";
177	GPR_WRITE_CONTEXT_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
178	rename = "GPR_WRITE_"+toString(i)+"_NUM_REG" ;
179	GPR_WRITE_NUM_REG [i] = new sc_signal<Tgeneral_address_t > (rename.c_str());
180	rename = "GPR_WRITE_"+toString(i)+"_DATA" ;
181	GPR_WRITE_DATA [i] = new sc_signal<Tgeneral_data_t > (rename.c_str());
182	}
183
184	// ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
185
186	sc_signal<Tcontrol_t > ** SPR_WRITE_VAL = new sc_signal<Tcontrol_t > * [_param->_nb_spr_write];
187	sc_signal<Tcontext_t > ** SPR_WRITE_CONTEXT_ID = new sc_signal<Tcontext_t > * [_param->_nb_spr_write];
188	sc_signal<Tspecial_address_t > ** SPR_WRITE_NUM_REG = new sc_signal<Tspecial_address_t > * [_param->_nb_spr_write];
189	sc_signal<Tspecial_data_t > ** SPR_WRITE_DATA = new sc_signal<Tspecial_data_t > * [_param->_nb_spr_write];
190
191	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
192	{
193	rename = "SPR_WRITE_"+toString(i)+"_VAL" ;
194	SPR_WRITE_VAL [i] = new sc_signal<Tcontrol_t > (rename.c_str());
195	rename = "SPR_WRITE_"+toString(i)+"_CONTEXT_ID";
196	SPR_WRITE_CONTEXT_ID [i] = new sc_signal<Tcontext_t > (rename.c_str());
197	rename = "SPR_WRITE_"+toString(i)+"_NUM_REG" ;
198	SPR_WRITE_NUM_REG [i] = new sc_signal<Tspecial_address_t > (rename.c_str());
199	rename = "SPR_WRITE_"+toString(i)+"_DATA" ;
200	SPR_WRITE_DATA [i] = new sc_signal<Tspecial_data_t > (rename.c_str());
201	}
202
203	/********************************************************
204	* Instanciation
205	********************************************************/
206
207	cout << "<" << name << "> Instanciation of _Read_queue" << endl;
208
209	((_Read_queue->in_CLOCK )) ((CLOCK));
210	((_Read_queue->in_NRESET)) ((NRESET));
211
212
213	((_Read_queue-> in_READ_QUEUE_IN_VAL )) ((READ_QUEUE_IN_VAL ));
214	((_Read_queue->out_READ_QUEUE_IN_ACK )) ((READ_QUEUE_IN_ACK ));
215	((_Read_queue-> in_READ_QUEUE_IN_CONTEXT_ID )) ((READ_QUEUE_IN_CONTEXT_ID ));
216	((_Read_queue-> in_READ_QUEUE_IN_PACKET_ID )) ((READ_QUEUE_IN_PACKET_ID ));
217	((_Read_queue-> in_READ_QUEUE_IN_OPERATION )) ((READ_QUEUE_IN_OPERATION ));
218	((_Read_queue-> in_READ_QUEUE_IN_TYPE )) ((READ_QUEUE_IN_TYPE ));
219	((_Read_queue-> in_READ_QUEUE_IN_HAS_IMMEDIAT )) ((READ_QUEUE_IN_HAS_IMMEDIAT ));
220	((_Read_queue-> in_READ_QUEUE_IN_IMMEDIAT )) ((READ_QUEUE_IN_IMMEDIAT ));
221	((_Read_queue-> in_READ_QUEUE_IN_READ_RA )) ((READ_QUEUE_IN_READ_RA ));
222	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RA )) ((READ_QUEUE_IN_NUM_REG_RA ));
223	((_Read_queue-> in_READ_QUEUE_IN_READ_RB )) ((READ_QUEUE_IN_READ_RB ));
224	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RB )) ((READ_QUEUE_IN_NUM_REG_RB ));
225	((_Read_queue-> in_READ_QUEUE_IN_READ_RC )) ((READ_QUEUE_IN_READ_RC ));
226	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RC )) ((READ_QUEUE_IN_NUM_REG_RC ));
227	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RD )) ((READ_QUEUE_IN_WRITE_RD ));
228	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RD )) ((READ_QUEUE_IN_NUM_REG_RD ));
229	((_Read_queue-> in_READ_QUEUE_IN_WRITE_RE )) ((READ_QUEUE_IN_WRITE_RE ));
230	((_Read_queue-> in_READ_QUEUE_IN_NUM_REG_RE )) ((READ_QUEUE_IN_NUM_REG_RE ));
231
232	((_Read_queue->out_READ_QUEUE_OUT_VAL )) ((READ_QUEUE_OUT_VAL ));
233	((_Read_queue-> in_READ_QUEUE_OUT_ACK )) ((READ_QUEUE_OUT_ACK ));
234	((_Read_queue->out_READ_QUEUE_OUT_CONTEXT_ID )) ((READ_QUEUE_OUT_CONTEXT_ID ));
235	((_Read_queue->out_READ_QUEUE_OUT_PACKET_ID )) ((READ_QUEUE_OUT_PACKET_ID ));
236	((_Read_queue->out_READ_QUEUE_OUT_OPERATION )) ((READ_QUEUE_OUT_OPERATION ));
237	((_Read_queue->out_READ_QUEUE_OUT_TYPE )) ((READ_QUEUE_OUT_TYPE ));
238	((_Read_queue->out_READ_QUEUE_OUT_HAS_IMMEDIAT )) ((READ_QUEUE_OUT_HAS_IMMEDIAT ));
239	((_Read_queue->out_READ_QUEUE_OUT_IMMEDIAT )) ((READ_QUEUE_OUT_IMMEDIAT ));
240	((_Read_queue->out_READ_QUEUE_OUT_READ_RA )) ((READ_QUEUE_OUT_READ_RA ));
241	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RA )) ((READ_QUEUE_OUT_NUM_REG_RA ));
242	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA_VAL )) ((READ_QUEUE_OUT_DATA_RA_VAL ));
243	((_Read_queue->out_READ_QUEUE_OUT_DATA_RA )) ((READ_QUEUE_OUT_DATA_RA ));
244	((_Read_queue->out_READ_QUEUE_OUT_READ_RB )) ((READ_QUEUE_OUT_READ_RB ));
245	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RB )) ((READ_QUEUE_OUT_NUM_REG_RB ));
246	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB_VAL )) ((READ_QUEUE_OUT_DATA_RB_VAL ));
247	((_Read_queue->out_READ_QUEUE_OUT_DATA_RB )) ((READ_QUEUE_OUT_DATA_RB ));
248	((_Read_queue->out_READ_QUEUE_OUT_READ_RC )) ((READ_QUEUE_OUT_READ_RC ));
249	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RC )) ((READ_QUEUE_OUT_NUM_REG_RC ));
250	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC_VAL )) ((READ_QUEUE_OUT_DATA_RC_VAL ));
251	((_Read_queue->out_READ_QUEUE_OUT_DATA_RC )) ((READ_QUEUE_OUT_DATA_RC ));
252	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RD )) ((READ_QUEUE_OUT_WRITE_RD ));
253	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RD )) ((READ_QUEUE_OUT_NUM_REG_RD ));
254	((_Read_queue->out_READ_QUEUE_OUT_WRITE_RE )) ((READ_QUEUE_OUT_WRITE_RE ));
255	((_Read_queue->out_READ_QUEUE_OUT_NUM_REG_RE )) ((READ_QUEUE_OUT_NUM_REG_RE ));
256
257	for (uint32_t i=0; i<_param->_nb_gpr_read; i++)
258	{
259	((_Read_queue->out_GPR_READ_VAL [i])) ((GPR_READ_VAL [i]));
260	((_Read_queue-> in_GPR_READ_ACK [i])) ((GPR_READ_ACK [i]));
261	((_Read_queue->out_GPR_READ_CONTEXT_ID [i])) ((GPR_READ_CONTEXT_ID [i]));
262	((_Read_queue->out_GPR_READ_NUM_REG [i])) ((GPR_READ_NUM_REG [i]));
263	((_Read_queue-> in_GPR_READ_DATA [i])) ((GPR_READ_DATA [i]));
264	((_Read_queue-> in_GPR_READ_DATA_VAL [i])) ((GPR_READ_DATA_VAL [i]));
265	}
266
267	for (uint32_t i=0; i<_param->_nb_spr_read; i++)
268	{
269	((_Read_queue->out_SPR_READ_VAL [i])) ((SPR_READ_VAL [i]));
270	((_Read_queue-> in_SPR_READ_ACK [i])) ((SPR_READ_ACK [i]));
271	((_Read_queue->out_SPR_READ_CONTEXT_ID [i])) ((SPR_READ_CONTEXT_ID [i]));
272	((_Read_queue->out_SPR_READ_NUM_REG [i])) ((SPR_READ_NUM_REG [i]));
273	((_Read_queue-> in_SPR_READ_DATA [i])) ((SPR_READ_DATA [i]));
274	((_Read_queue-> in_SPR_READ_DATA_VAL [i])) ((SPR_READ_DATA_VAL [i]));
275	}
276
277	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
278	{
279	((_Read_queue-> in_GPR_WRITE_VAL [i])) ((GPR_WRITE_VAL [i]));
280	((_Read_queue-> in_GPR_WRITE_CONTEXT_ID [i])) ((GPR_WRITE_CONTEXT_ID [i]));
281	((_Read_queue-> in_GPR_WRITE_NUM_REG [i])) ((GPR_WRITE_NUM_REG [i]));
282	((_Read_queue-> in_GPR_WRITE_DATA [i])) ((GPR_WRITE_DATA [i]));
283	}
284
285	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
286	{
287	((_Read_queue-> in_SPR_WRITE_VAL [i])) ((SPR_WRITE_VAL [i]));
288	((_Read_queue-> in_SPR_WRITE_CONTEXT_ID [i])) ((SPR_WRITE_CONTEXT_ID [i]));
289	((_Read_queue-> in_SPR_WRITE_NUM_REG [i])) ((SPR_WRITE_NUM_REG [i]));
290	((_Read_queue-> in_SPR_WRITE_DATA [i])) ((SPR_WRITE_DATA [i]));
291	}
292
293	cout << "<" << name << "> Start Simulation ............" << endl;
294	Time * _time = new Time();
295
296	/********************************************************
297	* Simulation - Begin
298	********************************************************/
299
300	// Initialisation
301	const uint32_t nb_request = _param->_nb_packet;
302	//const uint32_t seed = 0;
303	const uint32_t seed = static_cast<uint32_t>(time(NULL));
304	srand(seed);
305
306	Tcontext_t _context_id [nb_request];
307	Tcontrol_t _read_ra [nb_request];
308	Tgeneral_address_t _num_reg_ra [nb_request];
309	Tcontrol_t _read_rb [nb_request];
310	Tgeneral_address_t _num_reg_rb [nb_request];
311	Tcontrol_t _read_rc [nb_request];
312	Tspecial_address_t _num_reg_rc [nb_request];
313
314	// emulation of registerFile
315	Tcontrol_t _gpr_val [_param->_nb_general_register][_param->_nb_context];
316	Tgeneral_data_t _gpr [_param->_nb_general_register][_param->_nb_context];
317	Tcontrol_t _spr_val [_param->_nb_special_register][_param->_nb_context];
318	Tspecial_data_t _spr [_param->_nb_special_register][_param->_nb_context];
319
320	SC_START(0);
321
322	// for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
323	// GPR_WRITE_VAL [i]->write (0);
324	// for (uint32_t i=0; i<_param->_nb_spr_write; i++)
325	// SPR_WRITE_VAL [i]->write (0);
326
327	NRESET->write(0);
328	SC_START(5);
329	NRESET->write(1);
330
331	LABEL("Loop of Test");
332
333	for (uint32_t iteration=0; iteration<NB_ITERATION; iteration ++)
334	{
335	LABEL("Iteration "+toString(iteration));
336	int32_t percent_transaction_queue_in = (rand()%50)+25;
337	int32_t percent_transaction_queue_out = (rand()%50)+25;
338	int32_t percent_registerfile_valid = (rand()%50)+25;
339	int32_t percent_transaction_registerfile = (rand()%74)+25;
340	int32_t percent_transaction_bypass = (rand()%50)+25;
341
342	LABEL("Initialisation");
343
344	for (uint32_t i=0; i<nb_request; i++)
345	{
346	_context_id [i] = rand()% _param->_nb_context ;
347	_read_ra [i] = rand()% 2 ;
348	_num_reg_ra [i] = rand()% _param->_nb_general_register ;
349	_read_rb [i] = rand()% 2 ;
350	_num_reg_rb [i] = rand()% _param->_nb_general_register ;
351	_read_rc [i] = rand()% 2 ;
352	_num_reg_rc [i] = rand()% _param->_nb_special_register ;
353	}
354
355	// emulation of registerFile
356	for (uint32_t j=0; j<_param->_nb_context; j++)
357	{
358	for (uint32_t i=0; i<_param->_nb_general_register; i++)
359	{
360	_gpr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
361	_gpr [i][j] = rand()%(1<<_param->_size_general_data);
362	}
363	for (uint32_t i=0; i<_param->_nb_special_register; i++)
364	{
365	_spr_val [i][j] = ((rand()%100) < percent_registerfile_valid);
366	_spr [i][j] = rand()%(1<<_param->_size_special_data);
367	}
368	}
369	// End initialisation .......
370
371	uint32_t request_in = 0;
372	uint32_t request_out = 0;
373
374	while (request_out < nb_request)
375	{
376	if ((request_in < nb_request) and
377	((rand()%100) < percent_transaction_queue_in))
378	{
379	READ_QUEUE_IN_VAL ->write(1);
380	READ_QUEUE_IN_CONTEXT_ID ->write(_context_id [request_in]);
381	READ_QUEUE_IN_PACKET_ID ->write(request_in);
382	READ_QUEUE_IN_OPERATION ->write(0);
383	READ_QUEUE_IN_TYPE ->write(0);
384	READ_QUEUE_IN_HAS_IMMEDIAT->write(0);
385	READ_QUEUE_IN_IMMEDIAT ->write(0);
386	READ_QUEUE_IN_READ_RA ->write(_read_ra [request_in]);
387	READ_QUEUE_IN_NUM_REG_RA ->write(_num_reg_ra [request_in]);
388	READ_QUEUE_IN_READ_RB ->write(_read_rb [request_in]);
389	READ_QUEUE_IN_NUM_REG_RB ->write(_num_reg_rb [request_in]);
390	READ_QUEUE_IN_READ_RC ->write(_read_rc [request_in]);
391	READ_QUEUE_IN_NUM_REG_RC ->write(_num_reg_rc [request_in]);
392	READ_QUEUE_IN_WRITE_RD ->write(0);
393	READ_QUEUE_IN_NUM_REG_RD ->write(0);
394	READ_QUEUE_IN_WRITE_RE ->write(0);
395	READ_QUEUE_IN_NUM_REG_RE ->write(0);
396	}
397	else
398	{
399	READ_QUEUE_IN_VAL ->write(0);
400	}
401
402	READ_QUEUE_OUT_ACK ->write((rand()%100) < percent_transaction_queue_out);
403
404	// RegisterFile access
405	for (uint32_t i=0; i<_param->_nb_gpr_read ; i++)
406	{
407	GPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
408	if (GPR_READ_VAL [i]->read())
409	{
410	Tgeneral_address_t num_reg = GPR_READ_NUM_REG [i]->read();
411	Tcontext_t context = GPR_READ_CONTEXT_ID [i]->read();
412
413	GPR_READ_DATA [i]->write(_gpr [num_reg][context]);
414	GPR_READ_DATA_VAL [i]->write(_gpr_val[num_reg][context]);
415	}
416	}
417	for (uint32_t i=0; i<_param->_nb_spr_read ; i++)
418	{
419	SPR_READ_ACK [i]->write((rand()%100) < percent_transaction_registerfile);
420
421	if (SPR_READ_VAL [i]->read())
422	{
423	Tspecial_address_t num_reg = SPR_READ_NUM_REG [i]->read();
424	Tcontext_t context = SPR_READ_CONTEXT_ID [i]->read();
425
426	SPR_READ_DATA [i]->write(_spr [num_reg][context]);
427	SPR_READ_DATA_VAL [i]->write(_spr_val[num_reg][context]);
428	}
429	}
430
431	// BYPASS
432	for (uint32_t i=0; i<_param->_nb_gpr_write; i++)
433	{
434	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
435	Tcontext_t context = rand()% _param->_nb_context;
436	Tgeneral_address_t num_reg = rand()% _param->_nb_general_register;
437	Tgeneral_data_t data = rand()%(1<<_param->_size_general_data);
438
439	GPR_WRITE_VAL [i]->write(val);
440	GPR_WRITE_CONTEXT_ID [i]->write(context);
441	GPR_WRITE_NUM_REG [i]->write(num_reg);
442	GPR_WRITE_DATA [i]->write(data);
443
444	if (val)
445	{
446	_gpr [num_reg][context] = data;
447	_gpr_val [num_reg][context] = 1;
448	}
449	}
450	for (uint32_t i=0; i<_param->_nb_spr_write; i++)
451	{
452	Tcontrol_t val = (rand()%100) < percent_transaction_bypass;
453	Tcontext_t context = rand()% _param->_nb_context;
454	Tspecial_address_t num_reg = rand()% _param->_nb_special_register;
455	Tspecial_data_t data = rand()%(1<<_param->_size_special_data);
456
457	SPR_WRITE_VAL [i]->write(val);
458	SPR_WRITE_CONTEXT_ID [i]->write(context);
459	SPR_WRITE_NUM_REG [i]->write(num_reg);
460	SPR_WRITE_DATA [i]->write(data);
461
462	if (val)
463	{
464	_spr [num_reg][context] = data;
465	_spr_val [num_reg][context] = 1;
466	}
467	}
468
469	SC_START(0);
470
471	LABEL("Test READ_QUEUE_IN : "+toString(READ_QUEUE_IN_VAL->read())+","+toString(READ_QUEUE_IN_ACK->read()));
472	if ((READ_QUEUE_IN_VAL->read() == 1) and
473	(READ_QUEUE_IN_ACK->read() == 1))
474	{
475	LABEL("Accepted READ_QUEUE_IN ["+toString(request_in)+"]");
476	request_in ++;
477	}
478	LABEL("Test READ_QUEUE_OUT : "+toString(READ_QUEUE_OUT_VAL->read())+","+toString(READ_QUEUE_OUT_ACK->read()));
479	if ((READ_QUEUE_OUT_VAL->read() == 1) and
480	(READ_QUEUE_OUT_ACK->read() == 1))
481	{
482	Tpacket_t packet_id = READ_QUEUE_OUT_PACKET_ID->read();
483
484	LABEL("Accepted READ_QUEUE_OUT ["+toString(packet_id)+"]");
485
486	TEST(uint32_t , packet_id ,request_out);
487
488	request_out ++;
489
490	TEST(Tcontext_t ,READ_QUEUE_OUT_CONTEXT_ID ->read(),_context_id [packet_id]);
491	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RA ->read(),_read_ra [packet_id]);
492	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RA ->read(),_num_reg_ra [packet_id]);
493	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RA_VAL->read(),not READ_QUEUE_OUT_READ_RA->read() or _gpr_val [_num_reg_ra[packet_id]][_context_id [packet_id]]);
494	if (READ_QUEUE_OUT_READ_RA ->read() and
495	READ_QUEUE_OUT_DATA_RA_VAL->read())
496	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RA ->read(),_gpr [_num_reg_ra[packet_id]][_context_id [packet_id]]);
497	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RB ->read(),_read_rb [packet_id]);
498	TEST(Tgeneral_address_t,READ_QUEUE_OUT_NUM_REG_RB ->read(),_num_reg_rb [packet_id]);
499	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RB_VAL->read(),not READ_QUEUE_OUT_READ_RB->read() or _gpr_val [_num_reg_rb[packet_id]][_context_id [packet_id]]);
500	if (READ_QUEUE_OUT_READ_RB ->read() and
501	READ_QUEUE_OUT_DATA_RB_VAL->read())
502	TEST(Tgeneral_data_t ,READ_QUEUE_OUT_DATA_RB ->read(),_gpr [_num_reg_rb[packet_id]][_context_id [packet_id]]);
503	TEST(Tcontrol_t ,READ_QUEUE_OUT_READ_RC ->read(),_read_rc [packet_id]);
504	TEST(Tspecial_address_t,READ_QUEUE_OUT_NUM_REG_RC ->read(),_num_reg_rc [packet_id]);
505	TEST(Tcontrol_t ,READ_QUEUE_OUT_DATA_RC_VAL->read(),not READ_QUEUE_OUT_READ_RC->read() or _spr_val [_num_reg_rc[packet_id]][_context_id [packet_id]]);
506	if (READ_QUEUE_OUT_READ_RC ->read() and
507	READ_QUEUE_OUT_DATA_RC_VAL->read())
508	TEST(Tspecial_data_t ,READ_QUEUE_OUT_DATA_RC ->read(),_spr [_num_reg_rc[packet_id]][_context_id [packet_id]]);
509	}
510	SC_START(1);
511	}
512	}
513
514	/********************************************************
515	* Simulation - End
516	********************************************************/
517
518	TEST_OK ("End of Simulation");
519	delete _time;
520	cout << "<" << name << "> ............ Stop Simulation" << endl;
521
522	delete CLOCK;
523	delete NRESET;
524
525	delete READ_QUEUE_IN_VAL ;
526	delete READ_QUEUE_IN_ACK ;
527	delete READ_QUEUE_IN_CONTEXT_ID ;
528	delete READ_QUEUE_IN_PACKET_ID ;
529	delete READ_QUEUE_IN_OPERATION ;
530	delete READ_QUEUE_IN_TYPE ;
531	delete READ_QUEUE_IN_HAS_IMMEDIAT ;
532	delete READ_QUEUE_IN_IMMEDIAT ;
533	delete READ_QUEUE_IN_READ_RA ;
534	delete READ_QUEUE_IN_NUM_REG_RA ;
535	delete READ_QUEUE_IN_READ_RB ;
536	delete READ_QUEUE_IN_NUM_REG_RB ;
537	delete READ_QUEUE_IN_READ_RC ;
538	delete READ_QUEUE_IN_NUM_REG_RC ;
539	delete READ_QUEUE_IN_WRITE_RD ;
540	delete READ_QUEUE_IN_NUM_REG_RD ;
541	delete READ_QUEUE_IN_WRITE_RE ;
542	delete READ_QUEUE_IN_NUM_REG_RE ;
543
544	delete READ_QUEUE_OUT_VAL ;
545	delete READ_QUEUE_OUT_ACK ;
546	delete READ_QUEUE_OUT_CONTEXT_ID ;
547	delete READ_QUEUE_OUT_PACKET_ID ;
548	delete READ_QUEUE_OUT_OPERATION ;
549	delete READ_QUEUE_OUT_TYPE ;
550	delete READ_QUEUE_OUT_HAS_IMMEDIAT;
551	delete READ_QUEUE_OUT_IMMEDIAT ;
552	delete READ_QUEUE_OUT_READ_RA ;
553	delete READ_QUEUE_OUT_NUM_REG_RA ;
554	delete READ_QUEUE_OUT_DATA_RA_VAL ;
555	delete READ_QUEUE_OUT_DATA_RA ;
556	delete READ_QUEUE_OUT_READ_RB ;
557	delete READ_QUEUE_OUT_NUM_REG_RB ;
558	delete READ_QUEUE_OUT_DATA_RB_VAL ;
559	delete READ_QUEUE_OUT_DATA_RB ;
560	delete READ_QUEUE_OUT_READ_RC ;
561	delete READ_QUEUE_OUT_NUM_REG_RC ;
562	delete READ_QUEUE_OUT_DATA_RC_VAL ;
563	delete READ_QUEUE_OUT_DATA_RC ;
564	delete READ_QUEUE_OUT_WRITE_RD ;
565	delete READ_QUEUE_OUT_NUM_REG_RD ;
566	delete READ_QUEUE_OUT_WRITE_RE ;
567	delete READ_QUEUE_OUT_NUM_REG_RE ;
568
569	delete [] GPR_READ_VAL ;
570	delete [] GPR_READ_ACK ;
571	delete [] GPR_READ_NUM_REG ;
572	delete [] GPR_READ_DATA ;
573	delete [] GPR_READ_DATA_VAL;
574
575	delete [] SPR_READ_VAL ;
576	delete [] SPR_READ_ACK ;
577	delete [] SPR_READ_NUM_REG ;
578	delete [] SPR_READ_DATA ;
579	delete [] SPR_READ_DATA_VAL;
580
581	delete [] GPR_WRITE_VAL ;
582	delete [] GPR_WRITE_CONTEXT_ID ;
583	delete [] GPR_WRITE_NUM_REG ;
584	delete [] GPR_WRITE_DATA ;
585
586	delete [] SPR_WRITE_VAL ;
587	delete [] SPR_WRITE_CONTEXT_ID ;
588	delete [] SPR_WRITE_NUM_REG ;
589	delete [] SPR_WRITE_DATA ;
590	#endif
591
592	delete _Read_queue;
593
594	#ifdef STATISTICS
595	delete _parameters_statistics;
596	#endif
597	}

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

Download in other formats: