Context Navigation

source: trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/src/Register_unit_Glue_allocation.cpp @ 60

Last change on this file since 60 was 60, checked in by rosiere, 17 years ago

File size: 23.2 KB

Line
1	/*
2	* $Id$
3	*
4	* [ Description ]
5	*
6	*/
7
8	#include "Behavioural/Core/Multi_Execute_loop/Execute_loop/Register_unit/Register_unit_Glue/include/Register_unit_Glue.h"
9
10	namespace morpheo {
11	namespace behavioural {
12	namespace core {
13	namespace multi_execute_loop {
14	namespace execute_loop {
15	namespace register_unit {
16	namespace register_unit_glue {
17
18
19
20	#undef FUNCTION
21	#define FUNCTION "Register_unit_Glue::allocation"
22	void Register_unit_Glue::allocation (void)
23	{
24	string rename;
25
26	log_printf(FUNC,Register_unit_Glue,FUNCTION,"Begin");
27
28	_component = new Component ();
29
30	Entity * entity = _component->set_entity (_name
31	,"Register_unit_Glue"
32	#ifdef POSITION
33	,COMBINATORY
34	#endif
35	);
36
37	_interfaces = entity->set_interfaces();
38
39	// ~~~~~[ Interface : "" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
40
41	Interface * interface = _interfaces->set_interface(""
42	#ifdef POSITION
43	,IN
44	,SOUTH,
45	"Generalist interface"
46	#endif
47	);
48
49	in_CLOCK = interface->set_signal_clk ("clock" ,1, CLOCK_VHDL_NO);
50	in_NRESET = interface->set_signal_in <Tcontrol_t> ("nreset",1, RESET_VHDL_NO);
51	out_CONST_0 = interface->set_signal_out <Tcontrol_t> ("const_0",1);
52	out_CONST_1 = interface->set_signal_out <Tcontrol_t> ("const_1",1);
53
54	// ~~~~~[ Interface "gpr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
55	in_GPR_READ_VAL = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_read];
56	out_GPR_READ_ACK = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_read];
57	if (_param->_have_port_ooo_engine_id == true)
58	in_GPR_READ_OOO_ENGINE_ID = new SC_IN (Tcontext_t ) * [_param->_nb_gpr_read];
59	out_GPR_READ_DATA = new SC_OUT(Tgeneral_data_t ) * [_param->_nb_gpr_read];
60	out_GPR_READ_DATA_VAL = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_read];
61
62	out_GPR_READ_REGISTERFILE_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
63	in_GPR_READ_REGISTERFILE_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
64	in_GPR_READ_REGISTERFILE_DATA = new SC_IN (Tgeneral_data_t ) ** [_param->_nb_ooo_engine];
65
66	out_GPR_READ_STATUS_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
67	in_GPR_READ_STATUS_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
68	in_GPR_READ_STATUS_DATA_VAL = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
69
70	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
71	{
72	out_GPR_READ_REGISTERFILE_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_read];
73	in_GPR_READ_REGISTERFILE_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_read];
74	in_GPR_READ_REGISTERFILE_DATA [i] = new SC_IN (Tgeneral_data_t ) * [_param->_nb_gpr_read];
75
76	out_GPR_READ_STATUS_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_read];
77	in_GPR_READ_STATUS_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_read];
78	in_GPR_READ_STATUS_DATA_VAL [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_read];
79	}
80
81	for (uint32_t j=0; j<_param->_nb_gpr_read; j++)
82	{
83	Interface_fifo * interface = _interfaces->set_interface("gpr_read_"+toString(j)
84	#ifdef POSITION
85	,IN
86	,NORTH,
87	"Interface to read generalist register"
88	#endif
89	);
90
91	in_GPR_READ_VAL [j] = interface->set_signal_valack_in (VAL);
92	out_GPR_READ_ACK [j] = interface->set_signal_valack_out (ACK);
93	if (_param->_have_port_ooo_engine_id == true)
94	in_GPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
95	out_GPR_READ_DATA [j] = interface->set_signal_out<Tgeneral_data_t> ("data" , _param->_size_general_data);
96	out_GPR_READ_DATA_VAL [j] = interface->set_signal_out<Tcontrol_t > ("data_val" , 1);
97
98	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
99	{
100	{
101	Interface_fifo * interface = _interfaces->set_interface("gpr_read_registerfile_"+toString(i)+"_"+toString(j)
102	#ifdef POSITION
103	,IN
104	,NORTH,
105	"Interface to read generalist register - from/to register file"
106	#endif
107	);
108
109	out_GPR_READ_REGISTERFILE_VAL [i][j] = interface->set_signal_valack_out (VAL);
110	in_GPR_READ_REGISTERFILE_ACK [i][j] = interface->set_signal_valack_in (ACK);
111	in_GPR_READ_REGISTERFILE_DATA [i][j] = interface->set_signal_in <Tgeneral_data_t> ("data" , _param->_size_general_data);
112	}
113	{
114	Interface_fifo * interface = _interfaces->set_interface("gpr_read_status_"+toString(i)+"_"+toString(j)
115	#ifdef POSITION
116	,IN
117	,NORTH,
118	"Interface to read generalist register - from/to status"
119	#endif
120	);
121
122
123	out_GPR_READ_STATUS_VAL [i][j] = interface->set_signal_valack_out (VAL);
124	in_GPR_READ_STATUS_ACK [i][j] = interface->set_signal_valack_in (ACK);
125	in_GPR_READ_STATUS_DATA_VAL [i][j] = interface->set_signal_in <Tcontrol_t > ("data_val" , 1);
126	}
127	}
128	}
129
130	// ~~~~~[ Interface "spr_read" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
131	in_SPR_READ_VAL = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_read];
132	out_SPR_READ_ACK = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_read];
133	if (_param->_have_port_ooo_engine_id == true)
134	in_SPR_READ_OOO_ENGINE_ID = new SC_IN (Tcontext_t ) * [_param->_nb_spr_read];
135	out_SPR_READ_DATA = new SC_OUT(Tspecial_data_t ) * [_param->_nb_spr_read];
136	out_SPR_READ_DATA_VAL = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_read];
137
138	out_SPR_READ_REGISTERFILE_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
139	in_SPR_READ_REGISTERFILE_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
140	in_SPR_READ_REGISTERFILE_DATA = new SC_IN (Tspecial_data_t ) ** [_param->_nb_ooo_engine];
141
142	out_SPR_READ_STATUS_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
143	in_SPR_READ_STATUS_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
144	in_SPR_READ_STATUS_DATA_VAL = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
145
146	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
147	{
148	out_SPR_READ_REGISTERFILE_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_read];
149	in_SPR_READ_REGISTERFILE_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_read];
150	in_SPR_READ_REGISTERFILE_DATA [i] = new SC_IN (Tspecial_data_t ) * [_param->_nb_spr_read];
151
152	out_SPR_READ_STATUS_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_read];
153	in_SPR_READ_STATUS_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_read];
154	in_SPR_READ_STATUS_DATA_VAL [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_read];
155	}
156
157	for (uint32_t j=0; j<_param->_nb_spr_read; j++)
158	{
159	Interface_fifo * interface = _interfaces->set_interface("spr_read_"+toString(j)
160	#ifdef POSITION
161	,IN
162	,NORTH,
163	"Interface to read special register"
164	#endif
165	);
166
167	in_SPR_READ_VAL [j] = interface->set_signal_valack_in (VAL);
168	out_SPR_READ_ACK [j] = interface->set_signal_valack_out (ACK);
169	if (_param->_have_port_ooo_engine_id == true)
170	in_SPR_READ_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
171	out_SPR_READ_DATA [j] = interface->set_signal_out<Tspecial_data_t> ("data" , _param->_size_special_data);
172	out_SPR_READ_DATA_VAL [j] = interface->set_signal_out<Tcontrol_t > ("data_val" , 1);
173
174	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
175	{
176	{
177	Interface_fifo * interface = _interfaces->set_interface("spr_read_registerfile_"+toString(i)+"_"+toString(j)
178	#ifdef POSITION
179	,IN
180	,NORTH,
181	"Interface to read special register - from/to register file"
182	#endif
183	);
184
185	out_SPR_READ_REGISTERFILE_VAL [i][j] = interface->set_signal_valack_out (VAL);
186	in_SPR_READ_REGISTERFILE_ACK [i][j] = interface->set_signal_valack_in (ACK);
187	in_SPR_READ_REGISTERFILE_DATA [i][j] = interface->set_signal_in <Tspecial_data_t> ("data" , _param->_size_special_data);
188	}
189	{
190	Interface_fifo * interface = _interfaces->set_interface("spr_read_status_"+toString(i)+"_"+toString(j)
191	#ifdef POSITION
192	,IN
193	,NORTH,
194	"Interface to read special register - from/to status"
195	#endif
196	);
197
198
199	out_SPR_READ_STATUS_VAL [i][j] = interface->set_signal_valack_out (VAL);
200	in_SPR_READ_STATUS_ACK [i][j] = interface->set_signal_valack_in (ACK);
201	in_SPR_READ_STATUS_DATA_VAL [i][j] = interface->set_signal_in <Tcontrol_t > ("data_val" , 1);
202	}
203	}
204	}
205
206	// ~~~~~[ Interface "gpr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
207	in_GPR_WRITE_VAL = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_write];
208	out_GPR_WRITE_ACK = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_write];
209	if (_param->_have_port_ooo_engine_id == true)
210	in_GPR_WRITE_OOO_ENGINE_ID = new SC_IN (Tcontext_t ) * [_param->_nb_gpr_write];
211
212	out_GPR_WRITE_REGISTERFILE_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
213	in_GPR_WRITE_REGISTERFILE_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
214
215	out_GPR_WRITE_STATUS_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
216	in_GPR_WRITE_STATUS_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
217
218	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
219	{
220	out_GPR_WRITE_REGISTERFILE_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_write];
221	in_GPR_WRITE_REGISTERFILE_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_write];
222
223	out_GPR_WRITE_STATUS_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_gpr_write];
224	in_GPR_WRITE_STATUS_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_gpr_write];
225	}
226
227	for (uint32_t j=0; j<_param->_nb_gpr_write; j++)
228	{
229	Interface_fifo * interface = _interfaces->set_interface("gpr_write_"+toString(j)
230	#ifdef POSITION
231	,IN
232	,NORTH,
233	"Interface to write generalist register"
234	#endif
235	);
236
237	in_GPR_WRITE_VAL [j] = interface->set_signal_valack_in (VAL);
238	out_GPR_WRITE_ACK [j] = interface->set_signal_valack_out (ACK);
239	if (_param->_have_port_ooo_engine_id == true)
240	in_GPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
241
242	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
243	{
244	{
245	Interface_fifo * interface = _interfaces->set_interface("gpr_write_registerfile_"+toString(i)+"_"+toString(j)
246	#ifdef POSITION
247	,IN
248	,NORTH,
249	"Interface to write generalist register - from/to register file"
250	#endif
251	);
252
253	out_GPR_WRITE_REGISTERFILE_VAL [i][j] = interface->set_signal_valack_out (VAL);
254	in_GPR_WRITE_REGISTERFILE_ACK [i][j] = interface->set_signal_valack_in (ACK);
255	}
256	{
257	Interface_fifo * interface = _interfaces->set_interface("gpr_write_status_"+toString(i)+"_"+toString(j)
258	#ifdef POSITION
259	,IN
260	,NORTH,
261	"Interface to write generalist register - from/to status"
262	#endif
263	);
264
265
266	out_GPR_WRITE_STATUS_VAL [i][j] = interface->set_signal_valack_out (VAL);
267	in_GPR_WRITE_STATUS_ACK [i][j] = interface->set_signal_valack_in (ACK);
268	}
269	}
270	}
271
272	// ~~~~~[ Interface "spr_write" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
273	in_SPR_WRITE_VAL = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_write];
274	out_SPR_WRITE_ACK = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_write];
275	if (_param->_have_port_ooo_engine_id == true)
276	in_SPR_WRITE_OOO_ENGINE_ID = new SC_IN (Tcontext_t ) * [_param->_nb_spr_write];
277
278	out_SPR_WRITE_REGISTERFILE_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
279	in_SPR_WRITE_REGISTERFILE_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
280
281	out_SPR_WRITE_STATUS_VAL = new SC_OUT(Tcontrol_t ) ** [_param->_nb_ooo_engine];
282	in_SPR_WRITE_STATUS_ACK = new SC_IN (Tcontrol_t ) ** [_param->_nb_ooo_engine];
283
284	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
285	{
286	out_SPR_WRITE_REGISTERFILE_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_write];
287	in_SPR_WRITE_REGISTERFILE_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_write];
288
289	out_SPR_WRITE_STATUS_VAL [i] = new SC_OUT(Tcontrol_t ) * [_param->_nb_spr_write];
290	in_SPR_WRITE_STATUS_ACK [i] = new SC_IN (Tcontrol_t ) * [_param->_nb_spr_write];
291	}
292
293	for (uint32_t j=0; j<_param->_nb_spr_write; j++)
294	{
295	Interface_fifo * interface = _interfaces->set_interface("spr_write_"+toString(j)
296	#ifdef POSITION
297	,IN
298	,NORTH,
299	"Interface to write special register"
300	#endif
301	);
302
303	in_SPR_WRITE_VAL [j] = interface->set_signal_valack_in (VAL);
304	out_SPR_WRITE_ACK [j] = interface->set_signal_valack_out (ACK);
305	if (_param->_have_port_ooo_engine_id == true)
306	in_SPR_WRITE_OOO_ENGINE_ID [j] = interface->set_signal_in <Tcontext_t > ("ooo_engine_id", log2(_param->_nb_ooo_engine));
307
308	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
309	{
310	{
311	Interface_fifo * interface = _interfaces->set_interface("spr_write_registerfile_"+toString(i)+"_"+toString(j)
312	#ifdef POSITION
313	,IN
314	,NORTH,
315	"Interface to write special register - from/to register file"
316	#endif
317	);
318
319	out_SPR_WRITE_REGISTERFILE_VAL [i][j] = interface->set_signal_valack_out (VAL);
320	in_SPR_WRITE_REGISTERFILE_ACK [i][j] = interface->set_signal_valack_in (ACK);
321	}
322	{
323	Interface_fifo * interface = _interfaces->set_interface("spr_write_status_"+toString(i)+"_"+toString(j)
324	#ifdef POSITION
325	,IN
326	,NORTH,
327	"Interface to write special register - from/to status"
328	#endif
329	);
330
331
332	out_SPR_WRITE_STATUS_VAL [i][j] = interface->set_signal_valack_out (VAL);
333	in_SPR_WRITE_STATUS_ACK [i][j] = interface->set_signal_valack_in (ACK);
334	}
335	}
336	}
337
338	// ~~~~~[ Interface "insert_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
339	in_INSERT_ROB_VAL = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
340	out_INSERT_ROB_ACK = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
341	in_INSERT_ROB_RD_USE = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
342	in_INSERT_ROB_RE_USE = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
343	out_INSERT_ROB_GPR_STATUS_VAL = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
344	in_INSERT_ROB_GPR_STATUS_ACK = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
345	out_INSERT_ROB_SPR_STATUS_VAL = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
346	in_INSERT_ROB_SPR_STATUS_ACK = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
347
348	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
349	{
350	uint32_t x=_param->_nb_inst_insert_rob [i];
351
352	in_INSERT_ROB_VAL [i] = new SC_IN (Tcontrol_t) * [x];
353	out_INSERT_ROB_ACK [i] = new SC_OUT(Tcontrol_t) * [x];
354	in_INSERT_ROB_RD_USE [i] = new SC_IN (Tcontrol_t) * [x];
355	in_INSERT_ROB_RE_USE [i] = new SC_IN (Tcontrol_t) * [x];
356	out_INSERT_ROB_GPR_STATUS_VAL [i] = new SC_OUT(Tcontrol_t) * [x];
357	in_INSERT_ROB_GPR_STATUS_ACK [i] = new SC_IN (Tcontrol_t) * [x];
358	out_INSERT_ROB_SPR_STATUS_VAL [i] = new SC_OUT(Tcontrol_t) * [x];
359	in_INSERT_ROB_SPR_STATUS_ACK [i] = new SC_IN (Tcontrol_t) * [x];
360
361	for (uint32_t j=0; j<x; j++)
362	{
363	{
364	Interface_fifo * interface = _interfaces->set_interface("insert_rob_"+toString(i)+"_"+toString(j)
365	#ifdef POSITION
366	,IN
367	,WEST
368	,"Interface to update status (insert)"
369	#endif
370	);
371
372	in_INSERT_ROB_VAL [i][j] = interface->set_signal_valack_in (VAL);
373	out_INSERT_ROB_ACK [i][j] = interface->set_signal_valack_out(ACK);
374	in_INSERT_ROB_RD_USE [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_use", 1);
375	in_INSERT_ROB_RE_USE [i][j] = interface->set_signal_in <Tcontrol_t> ("re_use", 1);
376	}
377	{
378	Interface_fifo * interface = _interfaces->set_interface("insert_rob_gpr_status_"+toString(i)+"_"+toString(j)
379	#ifdef POSITION
380	,IN
381	,EAST
382	,"Interface to update status (insert)"
383	#endif
384	);
385
386	out_INSERT_ROB_GPR_STATUS_VAL [i][j] = interface->set_signal_valack_out(VAL);
387	in_INSERT_ROB_GPR_STATUS_ACK [i][j] = interface->set_signal_valack_in (ACK);
388	}
389	{
390	Interface_fifo * interface = _interfaces->set_interface("insert_rob_spr_status_"+toString(i)+"_"+toString(j)
391	#ifdef POSITION
392	,IN
393	,EAST
394	,"Interface to update status (insert)"
395	#endif
396	);
397
398	out_INSERT_ROB_SPR_STATUS_VAL [i][j] = interface->set_signal_valack_out(VAL);
399	in_INSERT_ROB_SPR_STATUS_ACK [i][j] = interface->set_signal_valack_in (ACK);
400	}
401	}
402	}
403
404	// ~~~~~[ Interface "retire_rob" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
405	in_RETIRE_ROB_VAL = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
406	out_RETIRE_ROB_ACK = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
407	in_RETIRE_ROB_RD_OLD_USE = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
408	in_RETIRE_ROB_RD_NEW_USE = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
409	in_RETIRE_ROB_RE_OLD_USE = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
410	in_RETIRE_ROB_RE_NEW_USE = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
411	out_RETIRE_ROB_GPR_STATUS_OLD_VAL = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
412	out_RETIRE_ROB_GPR_STATUS_NEW_VAL = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
413	in_RETIRE_ROB_GPR_STATUS_OLD_ACK = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
414	in_RETIRE_ROB_GPR_STATUS_NEW_ACK = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
415	out_RETIRE_ROB_SPR_STATUS_OLD_VAL = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
416	out_RETIRE_ROB_SPR_STATUS_NEW_VAL = new SC_OUT(Tcontrol_t) ** [_param->_nb_ooo_engine];
417	in_RETIRE_ROB_SPR_STATUS_OLD_ACK = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
418	in_RETIRE_ROB_SPR_STATUS_NEW_ACK = new SC_IN (Tcontrol_t) ** [_param->_nb_ooo_engine];
419
420	for (uint32_t i=0; i<_param->_nb_ooo_engine; i++)
421	{
422	uint32_t x=_param->_nb_inst_retire_rob [i];
423
424	in_RETIRE_ROB_VAL [i] = new SC_IN (Tcontrol_t) * [x];
425	out_RETIRE_ROB_ACK [i] = new SC_OUT(Tcontrol_t) * [x];
426	in_RETIRE_ROB_RD_OLD_USE [i] = new SC_IN (Tcontrol_t) * [x];
427	in_RETIRE_ROB_RD_NEW_USE [i] = new SC_IN (Tcontrol_t) * [x];
428	in_RETIRE_ROB_RE_OLD_USE [i] = new SC_IN (Tcontrol_t) * [x];
429	in_RETIRE_ROB_RE_NEW_USE [i] = new SC_IN (Tcontrol_t) * [x];
430	out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i] = new SC_OUT(Tcontrol_t) * [x];
431	out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i] = new SC_OUT(Tcontrol_t) * [x];
432	in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i] = new SC_IN (Tcontrol_t) * [x];
433	in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i] = new SC_IN (Tcontrol_t) * [x];
434	out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i] = new SC_OUT(Tcontrol_t) * [x];
435	out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i] = new SC_OUT(Tcontrol_t) * [x];
436	in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i] = new SC_IN (Tcontrol_t) * [x];
437	in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i] = new SC_IN (Tcontrol_t) * [x];
438
439	for (uint32_t j=0; j<x; j++)
440	{
441	{
442	Interface_fifo * interface = _interfaces->set_interface("retire_rob_"+toString(i)+"_"+toString(j)
443	#ifdef POSITION
444	,IN
445	,WEST
446	,"Interface to update status (retire)"
447	#endif
448	);
449
450	in_RETIRE_ROB_VAL [i][j] = interface->set_signal_valack_in (VAL);
451	out_RETIRE_ROB_ACK [i][j] = interface->set_signal_valack_out(ACK);
452	in_RETIRE_ROB_RD_OLD_USE [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_old_use", 1);
453	in_RETIRE_ROB_RD_NEW_USE [i][j] = interface->set_signal_in <Tcontrol_t> ("rd_new_use", 1);
454	in_RETIRE_ROB_RE_OLD_USE [i][j] = interface->set_signal_in <Tcontrol_t> ("re_old_use", 1);
455	in_RETIRE_ROB_RE_NEW_USE [i][j] = interface->set_signal_in <Tcontrol_t> ("re_new_use", 1);
456	}
457	{
458	Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_old_"+toString(i)+"_"+toString(j)
459	#ifdef POSITION
460	,IN
461	,EAST
462	,"Interface to update status (retire)"
463	#endif
464	);
465
466	out_RETIRE_ROB_GPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
467	in_RETIRE_ROB_GPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
468	}
469	{
470	Interface_fifo * interface = _interfaces->set_interface("retire_rob_gpr_status_new_"+toString(i)+"_"+toString(j)
471	#ifdef POSITION
472	,IN
473	,EAST
474	,"Interface to update status (retire)"
475	#endif
476	);
477
478	out_RETIRE_ROB_GPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
479	in_RETIRE_ROB_GPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
480	}
481	{
482	Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_old_"+toString(i)+"_"+toString(j)
483	#ifdef POSITION
484	,IN
485	,EAST
486	,"Interface to update status (retire)"
487	#endif
488	);
489
490	out_RETIRE_ROB_SPR_STATUS_OLD_VAL [i][j] = interface->set_signal_valack_out(VAL);
491	in_RETIRE_ROB_SPR_STATUS_OLD_ACK [i][j] = interface->set_signal_valack_in (ACK);
492	}
493	{
494	Interface_fifo * interface = _interfaces->set_interface("retire_rob_spr_status_new_"+toString(i)+"_"+toString(j)
495	#ifdef POSITION
496	,IN
497	,EAST
498	,"Interface to update status (retire)"
499	#endif
500	);
501
502	out_RETIRE_ROB_SPR_STATUS_NEW_VAL [i][j] = interface->set_signal_valack_out(VAL);
503	in_RETIRE_ROB_SPR_STATUS_NEW_ACK [i][j] = interface->set_signal_valack_in (ACK);
504	}
505	}
506	}
507
508	// ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
509
510	#ifdef POSITION
511	_component->generate_file();
512	#endif
513
514	log_printf(FUNC,Register_unit_Glue,FUNCTION,"End");
515	};
516
517	}; // end namespace register_unit_glue
518	}; // end namespace register_unit
519	}; // end namespace execute_loop
520	}; // end namespace multi_execute_loop
521	}; // end namespace core
522
523	}; // end namespace behavioural
524	}; // end namespace morpheo

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

Download in other formats: