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