Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

tsar_super_cluster.cpp @ 1040

Last change on this file since 1040 was 1040, checked in by bouyer, 8 years ago
Add a platform using the new dspin 3d router. Only giet-vm is suported at this time. The software is not aware of the 3d layout; the software's y dimention is subdivided in hardware y and z.
File size: 30.3 KB

Line
1	///////////////////////////////////////////////////////////////////////////////
2	// File: tsar_super_cluster.cpp
3	// Author: Manuel Bouyer
4	// Copyright: UPMC/LIP6
5	// Date : march 2016
6	// This program is released under the GNU public license
7	//////////////////////////////////////////////////////////////////////////////
8	// This file define a TSAR super-cluster architecture with virtual memory.
9	// It uses a 2d-mesh of tsar_cluster_3d clusters, interconected by they
10	// X and Y ports. The Z ports are used to connect to other super-cluster
11	// or to a 3rd level mesh.
12	//////////////////////////////////////////////////////////////////////////////////
13
14	#include <systemc>
15	#include <sys/time.h>
16	#include <iostream>
17	#include <sstream>
18	#include <cstdlib>
19	#include <cstdarg>
20	#include <stdint.h>
21	#include "tsar_super_cluster.h"
22
23	#define _NORTH 0
24	#define _SOUTH 1
25	#define _EAST 2
26	#define _WEST 3
27	#define _UP 4
28	#define _DOWN 5
29
30	#define cluster(x,y,z) ((x << (m_y_width + m_z_width)) + (y << m_z_width) + z)
31
32	namespace soclib {
33	namespace caba {
34
35	////////////////////////////////////////////////////////////////////////////////////
36	template<size_t dspin_cmd_width,
37	size_t dspin_rsp_width,
38	typename vci_param_int,
39	typename vci_param_ext> TsarSuperCluster<dspin_cmd_width,
40	dspin_rsp_width,
41	vci_param_int,
42	vci_param_ext>::TsarSuperCluster(
43	////////////////////////////////////////////////////////////////////////////////////
44	sc_module_name insname,
45	size_t nb_procs,
46	size_t nb_ttys,
47	size_t nb_dmas,
48	size_t x_size,
49	size_t y_size,
50	size_t z_id,
51	size_t elevator_x,
52	size_t elevator_y,
53	const soclib::common::MappingTable &mtd,
54	const soclib::common::MappingTable &mtx,
55	size_t x_width,
56	size_t y_width,
57	size_t z_width,
58	size_t p_width,
59	size_t vci_srcid_width,
60	size_t tgtid_memc,
61	size_t tgtid_xicu,
62	size_t tgtid_mdma,
63	size_t tgtid_fbuf,
64	size_t tgtid_mtty,
65	size_t tgtid_brom,
66	size_t tgtid_mnic,
67	size_t tgtid_chbuf,
68	size_t tgtid_bdev,
69	size_t tgtid_simh,
70	size_t memc_ways,
71	size_t memc_sets,
72	size_t l1_i_ways,
73	size_t l1_i_sets,
74	size_t l1_d_ways,
75	size_t l1_d_sets,
76	size_t irq_per_processor,
77	size_t xram_latency,
78	size_t x_io,
79	size_t y_io,
80	size_t z_io,
81	size_t xfb,
82	size_t yfb,
83	char* disk_name,
84	size_t block_size,
85	size_t nic_channels,
86	char* nic_rx_name,
87	char* nic_tx_name,
88	uint32_t nic_timeout,
89	size_t chbufdma_channels,
90	const Loader & loader,
91	uint32_t frozen_cycles,
92	uint32_t debug_start_cycle,
93	bool memc_debug_ok,
94	bool proc_debug_ok)
95	: soclib::caba::BaseModule(insname),
96	p_clk("clk"),
97	p_resetn("resetn"),
98	m_x_size(x_size),
99	m_y_size(y_size),
100	m_z_id(z_id),
101	m_x_width(x_width),
102	m_y_width(y_width),
103	m_z_width(z_width) {
104
105	assert(x_size <= 32 && "x_size should be less than 32");
106	assert(y_size <= 32 && "y_size should be less than 32");
107
108	/////////////////////////////////////////////////////////////////////////////
109	// Vectors of ports definition and allocation
110	/////////////////////////////////////////////////////////////////////////////
111
112	p_cmd_in = alloc_elems<DspinInput<dspin_cmd_width> > ("p_cmd_in", 2);
113	p_cmd_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cmd_out", 2);
114
115	p_rsp_in = alloc_elems<DspinInput<dspin_rsp_width> > ("p_rsp_in", 2);
116	p_rsp_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_rsp_out", 2);
117
118	p_m2p_in = alloc_elems<DspinInput<dspin_cmd_width> > ("p_m2p_in", 2);
119	p_m2p_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_m2p_out", 2);
120
121	p_p2m_in = alloc_elems<DspinInput<dspin_rsp_width> > ("p_p2m_in", 2);
122	p_p2m_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_p2m_out", 2);
123
124	p_cla_in = alloc_elems<DspinInput<dspin_cmd_width> > ("p_cla_in", 2);
125	p_cla_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cla_out", 2);
126
127	/////////////////////////////////////////////////////////////////////////////
128	// Allocate array of clusters
129	/////////////////////////////////////////////////////////////////////////////
130	#ifdef _OPENMP
131	#pragma omp parallel
132	{
133	#pragma omp for
134	#endif
135	for (size_t i = 0; i < (x_size * y_size); i++) {
136	size_t x = i / y_size;
137	size_t y = i % y_size;
138	#ifdef _OPENMP
139	#pragma omp critical
140	{
141	#endif
142	std::ostringstream sc;
143	sc << "cluster_" << x << "_" << y << "_" << z_id;
144	std::cout << sc << std::endl;
145	clusters[x][y] = new TsarXbarCluster<dspin_cmd_width,
146	dspin_rsp_width,
147	vci_param_int,
148	vci_param_ext>
149	(
150	sc.str().c_str(),
151	nb_procs,
152	nb_ttys,
153	nb_dmas,
154	x,
155	y,
156	z_id,
157	cluster(x,y, z_id),
158	elevator_x,
159	elevator_y,
160	mtd,
161	mtx,
162	x_width,
163	y_width,
164	z_width,
165	vci_srcid_width - x_width - y_width - z_width, // l_id width,
166	p_width,
167	tgtid_memc,
168	tgtid_xicu,
169	tgtid_mdma,
170	tgtid_fbuf,
171	tgtid_mtty,
172	tgtid_brom,
173	tgtid_mnic,
174	tgtid_chbuf,
175	tgtid_bdev,
176	tgtid_simh,
177	memc_ways,
178	memc_sets,
179	l1_i_ways,
180	l1_i_sets,
181	l1_d_ways,
182	l1_d_sets,
183	irq_per_processor,
184	xram_latency,
185	x == x_io && y == y_io && z_id == z_io,
186	xfb,
187	yfb,
188	disk_name,
189	block_size,
190	nic_channels,
191	nic_rx_name,
192	nic_tx_name,
193	nic_timeout,
194	chbufdma_channels,
195	loader,
196	frozen_cycles,
197	debug_start_cycle,
198	memc_debug_ok,
199	proc_debug_ok);
200	#ifdef _OPENMP
201	} // critical
202	#endif
203	}
204	#ifdef _OPENMP
205	} // for
206	#endif
207
208	signal_dspin_h_cmd_inc =
209	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", x_size + 1, y_size);
210	signal_dspin_h_cmd_dec =
211	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", x_size + 1, y_size);
212	signal_dspin_h_rsp_inc =
213	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_inc", x_size + 1, y_size);
214	signal_dspin_h_rsp_dec =
215	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_dec", x_size + 1, y_size);
216	signal_dspin_h_m2p_inc =
217	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_m2p_inc", x_size+ 1 , y_size);
218	signal_dspin_h_m2p_dec =
219	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_m2p_dec", x_size + 1, y_size);
220	signal_dspin_h_p2m_inc =
221	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_p2m_inc", x_size + 1, y_size);
222	signal_dspin_h_p2m_dec =
223	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_p2m_dec", x_size + 1, y_size);
224	signal_dspin_h_cla_inc =
225	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cla_inc", x_size + 1, y_size);
226	signal_dspin_h_cla_dec =
227	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cla_dec", x_size + 1, y_size);
228
229	signal_dspin_v_cmd_inc =
230	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", x_size, y_size + 1);
231	signal_dspin_v_cmd_dec =
232	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", x_size, y_size + 1);
233	signal_dspin_v_rsp_inc =
234	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_inc", x_size, y_size + 1);
235	signal_dspin_v_rsp_dec =
236	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_dec", x_size, y_size + 1);
237	signal_dspin_v_m2p_inc =
238	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_m2p_inc", x_size, y_size + 1);
239	signal_dspin_v_m2p_dec =
240	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_m2p_dec", x_size, y_size + 1);
241	signal_dspin_v_p2m_inc =
242	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_p2m_inc", x_size, y_size + 1);
243	signal_dspin_v_p2m_dec =
244	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_p2m_dec", x_size, y_size + 1);
245	signal_dspin_v_cla_inc =
246	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cla_inc", x_size, y_size + 1);
247	signal_dspin_v_cla_dec =
248	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cla_dec", x_size, y_size + 1);
249
250	signal_dspin_zu_cmd_inc =
251	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zu_cmd_inc", x_size, y_size);
252	signal_dspin_zu_cmd_dec =
253	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zu_cmd_dec", x_size, y_size);
254	signal_dspin_zu_rsp_inc =
255	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zu_rsp_inc", x_size, y_size);
256	signal_dspin_zu_rsp_dec =
257	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zu_rsp_dec", x_size, y_size);
258	signal_dspin_zu_m2p_inc =
259	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zu_m2p_inc", x_size, y_size);
260	signal_dspin_zu_m2p_dec =
261	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zu_m2p_dec", x_size, y_size);
262	signal_dspin_zu_p2m_inc =
263	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zu_p2m_inc", x_size, y_size);
264	signal_dspin_zu_p2m_dec =
265	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zu_p2m_dec", x_size, y_size);
266	signal_dspin_zu_cla_inc =
267	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zu_cla_inc", x_size, y_size);
268	signal_dspin_zu_cla_dec =
269	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zu_cla_dec", x_size, y_size);
270
271	signal_dspin_zd_cmd_inc =
272	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zd_cmd_inc", x_size, y_size);
273	signal_dspin_zd_cmd_dec =
274	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zd_cmd_dec", x_size, y_size);
275	signal_dspin_zd_rsp_inc =
276	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zd_rsp_inc", x_size, y_size);
277	signal_dspin_zd_rsp_dec =
278	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zd_rsp_dec", x_size, y_size);
279	signal_dspin_zd_m2p_inc =
280	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zd_m2p_inc", x_size, y_size);
281	signal_dspin_zd_m2p_dec =
282	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zd_m2p_dec", x_size, y_size);
283	signal_dspin_zd_p2m_inc =
284	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zd_p2m_inc", x_size, y_size);
285	signal_dspin_zd_p2m_dec =
286	alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_zd_p2m_dec", x_size, y_size);
287	signal_dspin_zd_cla_inc =
288	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zd_cla_inc", x_size, y_size);
289	signal_dspin_zd_cla_dec =
290	alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_zd_cla_dec", x_size, y_size);
291
292	////////////////////////////////////////////////////////////////////////
293	// Net-list
294	////////////////////////////////////////////////////////////////////////
295	// Clock & RESET
296	for (int x = 0; x < x_size; x++) {
297	for (int y = 0; y < y_size; y++) {
298	clusters[x][y]->p_clk (p_clk);
299	clusters[x][y]->p_resetn (p_resetn);
300	}
301	}
302
303	// Inter Clusters horizontal connections
304	// This also includes signals on E/W boundaries
305	for (int x = 0; x < x_size; x++) {
306	for (int y = 0; y < y_size; y++) {
307	clusters[x][y]->p_cmd_out[_EAST] (signal_dspin_h_cmd_inc[x + 1][y]);
308	clusters[x][y]->p_cmd_in[_WEST] (signal_dspin_h_cmd_inc[x ][y]);
309	clusters[x][y]->p_cmd_in[_EAST] (signal_dspin_h_cmd_dec[x + 1][y]);
310	clusters[x][y]->p_cmd_out[_WEST] (signal_dspin_h_cmd_dec[x ][y]);
311
312	clusters[x][y]->p_rsp_out[_EAST] (signal_dspin_h_rsp_inc[x + 1][y]);
313	clusters[x][y]->p_rsp_in[_WEST] (signal_dspin_h_rsp_inc[x ][y]);
314	clusters[x][y]->p_rsp_in[_EAST] (signal_dspin_h_rsp_dec[x + 1][y]);
315	clusters[x][y]->p_rsp_out[_WEST] (signal_dspin_h_rsp_dec[x ][y]);
316
317	clusters[x][y]->p_m2p_out[_EAST] (signal_dspin_h_m2p_inc[x + 1][y]);
318	clusters[x][y]->p_m2p_in[_WEST] (signal_dspin_h_m2p_inc[x ][y]);
319	clusters[x][y]->p_m2p_in[_EAST] (signal_dspin_h_m2p_dec[x + 1][y]);
320	clusters[x][y]->p_m2p_out[_WEST] (signal_dspin_h_m2p_dec[x ][y]);
321
322	clusters[x][y]->p_p2m_out[_EAST] (signal_dspin_h_p2m_inc[x + 1][y]);
323	clusters[x][y]->p_p2m_in[_WEST] (signal_dspin_h_p2m_inc[x ][y]);
324	clusters[x][y]->p_p2m_in[_EAST] (signal_dspin_h_p2m_dec[x + 1][y]);
325	clusters[x][y]->p_p2m_out[_WEST] (signal_dspin_h_p2m_dec[x ][y]);
326
327	clusters[x][y]->p_cla_out[_EAST] (signal_dspin_h_cla_inc[x + 1][y]);
328	clusters[x][y]->p_cla_in[_WEST] (signal_dspin_h_cla_inc[x ][y]);
329	clusters[x][y]->p_cla_in[_EAST] (signal_dspin_h_cla_dec[x + 1][y]);
330	clusters[x][y]->p_cla_out[_WEST] (signal_dspin_h_cla_dec[x ][y]);
331	}
332	}
333	// Inter Clusters vertical connections
334	// This also includes signals on N/S boundaries
335	for (int y = 0; y < y_size; y++) {
336	for (int x = 0; x < x_size; x++) {
337	clusters[x][y]->p_cmd_out[_NORTH] (signal_dspin_v_cmd_inc[x][y + 1]);
338	clusters[x][y]->p_cmd_in[_SOUTH] (signal_dspin_v_cmd_inc[x][y ]);
339	clusters[x][y]->p_cmd_in[_NORTH] (signal_dspin_v_cmd_dec[x][y + 1]);
340	clusters[x][y]->p_cmd_out[_SOUTH] (signal_dspin_v_cmd_dec[x][y ]);
341
342	clusters[x][y]->p_rsp_out[_NORTH] (signal_dspin_v_rsp_inc[x][y + 1]);
343	clusters[x][y]->p_rsp_in[_SOUTH] (signal_dspin_v_rsp_inc[x][y ]);
344	clusters[x][y]->p_rsp_in[_NORTH] (signal_dspin_v_rsp_dec[x][y + 1]);
345	clusters[x][y]->p_rsp_out[_SOUTH] (signal_dspin_v_rsp_dec[x][y ]);
346
347	clusters[x][y]->p_m2p_out[_NORTH] (signal_dspin_v_m2p_inc[x][y + 1]);
348	clusters[x][y]->p_m2p_in[_SOUTH] (signal_dspin_v_m2p_inc[x][y ]);
349	clusters[x][y]->p_m2p_in[_NORTH] (signal_dspin_v_m2p_dec[x][y + 1]);
350	clusters[x][y]->p_m2p_out[_SOUTH] (signal_dspin_v_m2p_dec[x][y ]);
351
352	clusters[x][y]->p_p2m_out[_NORTH] (signal_dspin_v_p2m_inc[x][y + 1]);
353	clusters[x][y]->p_p2m_in[_SOUTH] (signal_dspin_v_p2m_inc[x][y ]);
354	clusters[x][y]->p_p2m_in[_NORTH] (signal_dspin_v_p2m_dec[x][y + 1]);
355	clusters[x][y]->p_p2m_out[_SOUTH] (signal_dspin_v_p2m_dec[x][y ]);
356
357	clusters[x][y]->p_cla_out[_NORTH] (signal_dspin_v_cla_inc[x][y + 1]);
358	clusters[x][y]->p_cla_in[_SOUTH] (signal_dspin_v_cla_inc[x][y ]);
359	clusters[x][y]->p_cla_in[_NORTH] (signal_dspin_v_cla_dec[x][y + 1]);
360	clusters[x][y]->p_cla_out[_SOUTH] (signal_dspin_v_cla_dec[x][y ]);
361	}
362	}
363
364	// z-signals connections.
365	// the elevator is connected to the interface signals, others are
366	// connected to Null sources/sinks
367	for (size_t y = 0; y < y_size; y++) {
368	for (size_t x = 0; x < x_size; x++) {
369	if (x == elevator_x && y == elevator_y) {
370	clusters[x][y]->p_cmd_out[_UP] (p_cmd_out[0]);
371	clusters[x][y]->p_cmd_out[_DOWN] (p_cmd_out[1]);
372	clusters[x][y]->p_cmd_in[_UP] (p_cmd_in[0]);
373	clusters[x][y]->p_cmd_in[_DOWN] (p_cmd_in[1]);
374
375	clusters[x][y]->p_rsp_in[_UP] (p_rsp_in[0]);
376	clusters[x][y]->p_rsp_in[_DOWN] (p_rsp_in[1]);
377	clusters[x][y]->p_rsp_out[_UP] (p_rsp_out[0]);
378	clusters[x][y]->p_rsp_out[_DOWN] (p_rsp_out[1]);
379
380	clusters[x][y]->p_m2p_out[_UP] (p_m2p_out[0]);
381	clusters[x][y]->p_m2p_out[_DOWN] (p_m2p_out[1]);
382	clusters[x][y]->p_m2p_in[_UP] (p_m2p_in[0]);
383	clusters[x][y]->p_m2p_in[_DOWN] (p_m2p_in[1]);
384
385	clusters[x][y]->p_p2m_out[_UP] (p_p2m_out[0]);
386	clusters[x][y]->p_p2m_out[_DOWN] (p_p2m_out[1]);
387	clusters[x][y]->p_p2m_in[_UP] (p_p2m_in[0]);
388	clusters[x][y]->p_p2m_in[_DOWN] (p_p2m_in[1]);
389
390	clusters[x][y]->p_cla_out[_UP] (p_cla_out[0]);
391	clusters[x][y]->p_cla_out[_DOWN] (p_cla_out[1]);
392	clusters[x][y]->p_cla_in[_UP] (p_cla_in[0]);
393	clusters[x][y]->p_cla_in[_DOWN] (p_cla_in[1]);
394
395	} else {
396	clusters[x][y]->p_cmd_out[_UP] (signal_dspin_zu_cmd_inc[x][y]);
397	clusters[x][y]->p_cmd_in[_UP] (signal_dspin_zu_cmd_dec[x][y]);
398	clusters[x][y]->p_cmd_in[_DOWN] (signal_dspin_zd_cmd_inc[x][y]);
399	clusters[x][y]->p_cmd_out[_DOWN] (signal_dspin_zd_cmd_dec[x][y]);
400
401	clusters[x][y]->p_rsp_out[_UP] (signal_dspin_zu_rsp_inc[x][y]);
402	clusters[x][y]->p_rsp_in[_UP] (signal_dspin_zu_rsp_dec[x][y]);
403	clusters[x][y]->p_rsp_in[_DOWN] (signal_dspin_zd_rsp_inc[x][y]);
404	clusters[x][y]->p_rsp_out[_DOWN] (signal_dspin_zd_rsp_dec[x][y]);
405
406	clusters[x][y]->p_m2p_out[_UP] (signal_dspin_zu_m2p_inc[x][y]);
407	clusters[x][y]->p_m2p_in[_UP] (signal_dspin_zu_m2p_dec[x][y]);
408	clusters[x][y]->p_m2p_in[_DOWN] (signal_dspin_zd_m2p_inc[x][y]);
409	clusters[x][y]->p_m2p_out[_DOWN] (signal_dspin_zd_m2p_dec[x][y]);
410
411	clusters[x][y]->p_p2m_out[_UP] (signal_dspin_zu_p2m_inc[x][y]);
412	clusters[x][y]->p_p2m_in[_UP] (signal_dspin_zu_p2m_dec[x][y]);
413	clusters[x][y]->p_p2m_in[_DOWN] (signal_dspin_zd_p2m_inc[x][y]);
414	clusters[x][y]->p_p2m_out[_DOWN] (signal_dspin_zd_p2m_dec[x][y]);
415
416	clusters[x][y]->p_cla_out[_UP] (signal_dspin_zu_cla_inc[x][y]);
417	clusters[x][y]->p_cla_in[_UP] (signal_dspin_zu_cla_dec[x][y]);
418	clusters[x][y]->p_cla_in[_DOWN] (signal_dspin_zd_cla_inc[x][y]);
419	clusters[x][y]->p_cla_out[_DOWN] (signal_dspin_zd_cla_dec[x][y]);
420	}
421	}
422	}
423
424	} // end constructor
425
426
427
428	template<size_t dspin_cmd_width,
429	size_t dspin_rsp_width,
430	typename vci_param_int,
431	typename vci_param_ext> TsarSuperCluster<dspin_cmd_width,
432	dspin_rsp_width,
433	vci_param_int,
434	vci_param_ext>::~TsarSuperCluster() {
435
436	dealloc_elems<DspinInput<dspin_cmd_width> > (p_cmd_in, 2);
437	dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cmd_out, 2);
438
439	dealloc_elems<DspinInput<dspin_rsp_width> > (p_rsp_in, 2);
440	dealloc_elems<DspinOutput<dspin_rsp_width> >(p_rsp_out, 2);
441
442	dealloc_elems<DspinInput<dspin_cmd_width> > (p_m2p_in, 2);
443	dealloc_elems<DspinOutput<dspin_cmd_width> >(p_m2p_out, 2);
444
445	dealloc_elems<DspinInput<dspin_rsp_width> > (p_p2m_in, 2);
446	dealloc_elems<DspinOutput<dspin_rsp_width> >(p_p2m_out, 2);
447
448	dealloc_elems<DspinInput<dspin_cmd_width> > (p_cla_in, 2);
449	dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cla_out, 2);
450
451	for (size_t i = 0; i < (m_x_size * m_y_size); i++) {
452	size_t x = i / m_y_size;
453	size_t y = i % m_y_size;
454	delete clusters[x][y];
455	}
456	}
457
458
459	template<size_t dspin_cmd_width,
460	size_t dspin_rsp_width,
461	typename vci_param_int,
462	typename vci_param_ext>
463	void TsarSuperCluster<dspin_cmd_width,
464	dspin_rsp_width,
465	vci_param_int,
466	vci_param_ext>::trace(sc_core::sc_trace_file * tf) {
467
468	for (size_t i = 0; i < (m_x_size * m_y_size); i++) {
469	std::ostringstream signame;
470	size_t x = i / m_y_size;
471	size_t y = i % m_y_size;
472
473	signame << "cluster" << x << "_" << y << "_" << m_z_id;
474	std::cout << "trace " << signame.str() << std::endl;
475	clusters[x][y]->trace(tf, signame.str());
476	sc_core::sc_trace(tf, p_resetn, "resetn");
477	}
478	for (size_t x = 0; x < m_x_size + 1; x++) {
479	for (size_t y = 0; y < m_y_size + 1; y++) {
480	if (x < m_x_size \|\| y < m_y_size) {
481	std::ostringstream signame;
482	signame << "l[" << x << "][" << y << "]";
483	#define __trace(s) s[x][y].trace(tf, signame.str() + "_" + #s); std::cout << "trace " << signame.str() + "_" + #s << std::endl;
484	if (y < m_y_size) {
485	__trace(signal_dspin_h_cmd_inc);
486	__trace(signal_dspin_h_cmd_dec);
487	}
488	if (x < m_x_size) {
489	__trace(signal_dspin_v_cmd_inc);
490	__trace(signal_dspin_v_cmd_dec);
491	}
492	if (x < m_x_size && y < m_y_size) {
493	__trace(signal_dspin_zu_cmd_inc);
494	__trace(signal_dspin_zu_cmd_dec);
495	__trace(signal_dspin_zd_cmd_inc);
496	__trace(signal_dspin_zd_cmd_dec);
497	}
498	if (y < m_y_size) {
499	__trace(signal_dspin_h_rsp_inc);
500	__trace(signal_dspin_h_rsp_dec);
501	}
502	if (x < m_x_size) {
503	__trace(signal_dspin_v_rsp_inc);
504	__trace(signal_dspin_v_rsp_dec);
505	}
506	if (x < m_x_size && y < m_y_size) {
507	__trace(signal_dspin_zu_rsp_inc);
508	__trace(signal_dspin_zu_rsp_dec);
509	__trace(signal_dspin_zd_rsp_inc);
510	__trace(signal_dspin_zd_rsp_dec);
511	}
512	if (y < m_y_size) {
513	__trace(signal_dspin_h_m2p_inc);
514	__trace(signal_dspin_h_m2p_dec);
515	}
516	if (x < m_x_size) {
517	__trace(signal_dspin_v_m2p_inc);
518	__trace(signal_dspin_v_m2p_dec);
519	}
520	if (x < m_x_size && y < m_y_size) {
521	__trace(signal_dspin_zu_m2p_inc);
522	__trace(signal_dspin_zu_m2p_dec);
523	__trace(signal_dspin_zd_m2p_inc);
524	__trace(signal_dspin_zd_m2p_dec);
525	}
526	if (y < m_y_size) {
527	__trace(signal_dspin_h_p2m_inc);
528	__trace(signal_dspin_h_p2m_dec);
529	}
530	if (x < m_x_size) {
531	__trace(signal_dspin_v_p2m_inc);
532	__trace(signal_dspin_v_p2m_dec);
533	}
534	if (x < m_x_size && y < m_y_size) {
535	__trace(signal_dspin_zu_p2m_inc);
536	__trace(signal_dspin_zu_p2m_dec);
537	__trace(signal_dspin_zd_p2m_inc);
538	__trace(signal_dspin_zd_p2m_dec);
539	}
540	if (y < m_y_size) {
541	__trace(signal_dspin_h_cla_inc);
542	__trace(signal_dspin_h_cla_dec);
543	}
544	if (x < m_x_size) {
545	__trace(signal_dspin_v_cla_inc);
546	__trace(signal_dspin_v_cla_dec);
547	}
548	if (x < m_x_size && y < m_y_size) {
549	__trace(signal_dspin_zu_cla_inc);
550	__trace(signal_dspin_zu_cla_dec);
551	__trace(signal_dspin_zd_cla_inc);
552	__trace(signal_dspin_zd_cla_dec);
553	}
554	}
555	}
556	}
557	}
558
559	template<size_t dspin_cmd_width,
560	size_t dspin_rsp_width,
561	typename vci_param_int,
562	typename vci_param_ext>
563	void TsarSuperCluster<dspin_cmd_width,
564	dspin_rsp_width,
565	vci_param_int,
566	vci_param_ext>::reset() {
567	// setup boundaries signals
568	for (size_t y = 0; y < m_y_size; y++) {
569	signal_dspin_h_cmd_inc[0][y].write = false;
570	signal_dspin_h_cmd_inc[0][y].read = true;
571	signal_dspin_h_cmd_dec[0][y].write = false;
572	signal_dspin_h_cmd_dec[0][y].read = true;
573	signal_dspin_h_cmd_inc[m_x_size][y].write = false;
574	signal_dspin_h_cmd_inc[m_x_size][y].read = true;
575	signal_dspin_h_cmd_dec[m_x_size][y].write = false;
576	signal_dspin_h_cmd_dec[m_x_size][y].read = true;
577
578	signal_dspin_h_rsp_inc[0][y].write = false;
579	signal_dspin_h_rsp_inc[0][y].read = true;
580	signal_dspin_h_rsp_dec[0][y].write = false;
581	signal_dspin_h_rsp_dec[0][y].read = true;
582	signal_dspin_h_rsp_inc[m_x_size][y].write = false;
583	signal_dspin_h_rsp_inc[m_x_size][y].read = true;
584	signal_dspin_h_rsp_dec[m_x_size][y].write = false;
585	signal_dspin_h_rsp_dec[m_x_size][y].read = true;
586
587	signal_dspin_h_m2p_inc[0][y].write = false;
588	signal_dspin_h_m2p_inc[0][y].read = true;
589	signal_dspin_h_m2p_dec[0][y].write = false;
590	signal_dspin_h_m2p_dec[0][y].read = true;
591	signal_dspin_h_m2p_inc[m_x_size][y].write = false;
592	signal_dspin_h_m2p_inc[m_x_size][y].read = true;
593	signal_dspin_h_m2p_dec[m_x_size][y].write = false;
594	signal_dspin_h_m2p_dec[m_x_size][y].read = true;
595
596	signal_dspin_h_p2m_inc[0][y].write = false;
597	signal_dspin_h_p2m_inc[0][y].read = true;
598	signal_dspin_h_p2m_dec[0][y].write = false;
599	signal_dspin_h_p2m_dec[0][y].read = true;
600	signal_dspin_h_p2m_inc[m_x_size][y].write = false;
601	signal_dspin_h_p2m_inc[m_x_size][y].read = true;
602	signal_dspin_h_p2m_dec[m_x_size][y].write = false;
603	signal_dspin_h_p2m_dec[m_x_size][y].read = true;
604
605	signal_dspin_h_cla_inc[0][y].write = false;
606	signal_dspin_h_cla_inc[0][y].read = true;
607	signal_dspin_h_cla_dec[0][y].write = false;
608	signal_dspin_h_cla_dec[0][y].read = true;
609	signal_dspin_h_cla_inc[m_x_size][y].write = false;
610	signal_dspin_h_cla_inc[m_x_size][y].read = true;
611	signal_dspin_h_cla_dec[m_x_size][y].write = false;
612	signal_dspin_h_cla_dec[m_x_size][y].read = true;
613	}
614
615	for (size_t x = 0; x < m_x_size; x++) {
616	signal_dspin_v_cmd_inc[x][0].write = false;
617	signal_dspin_v_cmd_inc[x][0].read = true;
618	signal_dspin_v_cmd_dec[x][0].write = false;
619	signal_dspin_v_cmd_dec[x][0].read = true;
620	signal_dspin_v_cmd_inc[x][m_y_size].write = false;
621	signal_dspin_v_cmd_inc[x][m_y_size].read = true;
622	signal_dspin_v_cmd_dec[x][m_y_size].write = false;
623	signal_dspin_v_cmd_dec[x][m_y_size].read = true;
624
625	signal_dspin_v_rsp_inc[x][0].write = false;
626	signal_dspin_v_rsp_inc[x][0].read = true;
627	signal_dspin_v_rsp_dec[x][0].write = false;
628	signal_dspin_v_rsp_dec[x][0].read = true;
629	signal_dspin_v_rsp_inc[x][m_y_size].write = false;
630	signal_dspin_v_rsp_inc[x][m_y_size].read = true;
631	signal_dspin_v_rsp_dec[x][m_y_size].write = false;
632	signal_dspin_v_rsp_dec[x][m_y_size].read = true;
633
634	signal_dspin_v_m2p_inc[x][0].write = false;
635	signal_dspin_v_m2p_inc[x][0].read = true;
636	signal_dspin_v_m2p_dec[x][0].write = false;
637	signal_dspin_v_m2p_dec[x][0].read = true;
638	signal_dspin_v_m2p_inc[x][m_y_size].write = false;
639	signal_dspin_v_m2p_inc[x][m_y_size].read = true;
640	signal_dspin_v_m2p_dec[x][m_y_size].write = false;
641	signal_dspin_v_m2p_dec[x][m_y_size].read = true;
642
643	signal_dspin_v_p2m_inc[x][0].write = false;
644	signal_dspin_v_p2m_inc[x][0].read = true;
645	signal_dspin_v_p2m_dec[x][0].write = false;
646	signal_dspin_v_p2m_dec[x][0].read = true;
647	signal_dspin_v_p2m_inc[x][m_y_size].write = false;
648	signal_dspin_v_p2m_inc[x][m_y_size].read = true;
649	signal_dspin_v_p2m_dec[x][m_y_size].write = false;
650	signal_dspin_v_p2m_dec[x][m_y_size].read = true;
651
652	signal_dspin_v_cla_inc[x][0].write = false;
653	signal_dspin_v_cla_inc[x][0].read = true;
654	signal_dspin_v_cla_dec[x][0].write = false;
655	signal_dspin_v_cla_dec[x][0].read = true;
656	signal_dspin_v_cla_inc[x][m_y_size].write = false;
657	signal_dspin_v_cla_inc[x][m_y_size].read = true;
658	signal_dspin_v_cla_dec[x][m_y_size].write = false;
659	signal_dspin_v_cla_dec[x][m_y_size].read = true;
660	}
661	for (size_t x = 0; x < m_x_size; x++) {
662	for (size_t y = 0; y < m_y_size; y++) {
663	signal_dspin_zu_cmd_inc[x][y].write = false;
664	signal_dspin_zu_cmd_inc[x][y].read = true;
665	signal_dspin_zu_cmd_dec[x][y].write = false;
666	signal_dspin_zu_cmd_dec[x][y].read = true;
667	signal_dspin_zd_cmd_inc[x][y].write = false;
668	signal_dspin_zd_cmd_inc[x][y].read = true;
669	signal_dspin_zd_cmd_dec[x][y].write = false;
670	signal_dspin_zd_cmd_dec[x][y].read = true;
671
672	signal_dspin_zu_rsp_inc[x][y].write = false;
673	signal_dspin_zu_rsp_inc[x][y].read = true;
674	signal_dspin_zu_rsp_dec[x][y].write = false;
675	signal_dspin_zu_rsp_dec[x][y].read = true;
676	signal_dspin_zd_rsp_inc[x][y].write = false;
677	signal_dspin_zd_rsp_inc[x][y].read = true;
678	signal_dspin_zd_rsp_dec[x][y].write = false;
679	signal_dspin_zd_rsp_dec[x][y].read = true;
680
681	signal_dspin_zu_m2p_inc[x][y].write = false;
682	signal_dspin_zu_m2p_inc[x][y].read = true;
683	signal_dspin_zu_m2p_dec[x][y].write = false;
684	signal_dspin_zu_m2p_dec[x][y].read = true;
685	signal_dspin_zd_m2p_inc[x][y].write = false;
686	signal_dspin_zd_m2p_inc[x][y].read = true;
687	signal_dspin_zd_m2p_dec[x][y].write = false;
688	signal_dspin_zd_m2p_dec[x][y].read = true;
689
690	signal_dspin_zu_p2m_inc[x][y].write = false;
691	signal_dspin_zu_p2m_inc[x][y].read = true;
692	signal_dspin_zu_p2m_dec[x][y].write = false;
693	signal_dspin_zu_p2m_dec[x][y].read = true;
694	signal_dspin_zd_p2m_inc[x][y].write = false;
695	signal_dspin_zd_p2m_inc[x][y].read = true;
696	signal_dspin_zd_p2m_dec[x][y].write = false;
697	signal_dspin_zd_p2m_dec[x][y].read = true;
698
699	signal_dspin_zu_cla_inc[x][y].write = false;
700	signal_dspin_zu_cla_inc[x][y].read = true;
701	signal_dspin_zu_cla_dec[x][y].write = false;
702	signal_dspin_zu_cla_dec[x][y].read = true;
703	signal_dspin_zd_cla_inc[x][y].write = false;
704	signal_dspin_zd_cla_inc[x][y].read = true;
705	signal_dspin_zd_cla_dec[x][y].write = false;
706	signal_dspin_zd_cla_dec[x][y].read = true;
707	}
708	}
709	}
710
711
712	}}
713
714	// Local Variables:
715	// tab-width: 4
716	// c-basic-offset: 4
717	// c-file-offsets:((innamespace . 0)(inline-open . 0))
718	// indent-tabs-mode: nil
719	// End:
720
721	// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
722

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

Context Navigation

source: trunk/platforms/tsar_generic_3d/tsar_super_cluster/caba/source/src/tsar_super_cluster.cpp @ 1040

Download in other formats: