source: trunk/platforms/tsar_generic_leti/tsar_leti_cluster/caba/source/src/tsar_leti_cluster.cpp @ 664

Last change on this file since 664 was 664, checked in by alain, 10 years ago

Improved platform supporting both external an internal peripherals.
Iti has been validated with the GIET_VM for the following xml mappingss:

  • 4c_4p_sort_leti
  • 4c_4p_sort_leti_ext
  • 4c_4p_transpose_leti
  • 4c_4p_transpose_leti_ext
  • 4c_1p_four_leti_ext
File size: 30.7 KB
Line 
1//////////////////////////////////////////////////////////////////////////////
2// File: tsar_leti_cluster.cpp
3// Author: Alain Greiner
4// Copyright: UPMC/LIP6
5// Date : february 2014
6// This program is released under the GNU public license
7//////////////////////////////////////////////////////////////////////////////
8
9#include "../include/tsar_leti_cluster.h"
10
11namespace soclib {
12namespace caba  {
13
14////////////////////////////////////////////////////////////////////////////////////
15template<size_t dspin_cmd_width,
16         size_t dspin_rsp_width,
17         typename vci_param_int,
18         typename vci_param_ext> TsarLetiCluster<dspin_cmd_width,
19                                                 dspin_rsp_width,
20                                                 vci_param_int,
21                                                 vci_param_ext>::TsarLetiCluster(
22////////////////////////////////////////////////////////////////////////////////////
23         sc_module_name                     insname,
24         size_t                             nb_procs,
25         size_t                             x_id,
26         size_t                             y_id,
27         size_t                             cluster_xy,
28         const soclib::common::MappingTable &mtd,
29         const soclib::common::MappingTable &mtx,
30         uint32_t                           reset_address,
31         size_t                             x_width,
32         size_t                             y_width,
33         size_t                             l_width,
34         size_t                             tgtid_memc,
35         size_t                             tgtid_xicu,
36         size_t                             tgtid_mtty,
37         size_t                             tgtid_bdev,
38         const char*                        disk_pathname,
39         size_t                             memc_ways,
40         size_t                             memc_sets,
41         size_t                             l1_i_ways,
42         size_t                             l1_i_sets,
43         size_t                             l1_d_ways,
44         size_t                             l1_d_sets,
45         size_t                             xram_latency,
46         const Loader                      &loader,
47         uint32_t                           frozen_cycles,
48         uint32_t                           trace_start_cycle,
49         bool                               trace_proc_ok,
50         uint32_t                           trace_proc_id,
51         bool                               trace_memc_ok,
52         uint32_t                           trace_memc_id )
53            : soclib::caba::BaseModule(insname),
54            p_clk("clk"),
55            p_resetn("resetn")
56
57{
58    /////////////////////////////////////////////////////////////////////////////
59    // Vectors of ports definition and allocation
60    /////////////////////////////////////////////////////////////////////////////
61
62    p_cmd_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_cmd_in",  4);
63    p_cmd_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cmd_out", 4);
64
65    p_rsp_in  = alloc_elems<DspinInput<dspin_rsp_width> >  ("p_rsp_in",  4);
66    p_rsp_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_rsp_out", 4);
67
68    p_m2p_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_m2p_in",  4);
69    p_m2p_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_m2p_out", 4);
70
71    p_p2m_in  = alloc_elems<DspinInput<dspin_rsp_width> >  ("p_p2m_in",  4);
72    p_p2m_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_p2m_out", 4);
73
74    p_cla_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_cla_in",  4);
75    p_cla_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cla_out", 4);
76
77    /////////////////////////////////////////////////////////////////////////////
78    // Components definition and allocation
79    /////////////////////////////////////////////////////////////////////////////
80
81    // The processor is a MIPS32 wrapped in the GDB server
82    // the reset address is defined by the reset_address argument
83    typedef GdbServer<Mips32ElIss> mips_iss;
84    mips_iss::setResetAddress( reset_address );
85
86    for (size_t p = 0; p < nb_procs; p++)
87    {
88        uint32_t global_proc_id  = cluster_xy * nb_procs + p;
89        uint32_t global_cc_id    = (cluster_xy << l_width) + p;
90        bool     trace_ok        = trace_proc_ok and (trace_proc_id == global_proc_id);
91
92        std::ostringstream sproc;
93        sproc << "proc_" << x_id << "_" << y_id << "_" << p;
94        proc[p] = new VciCcVCacheWrapper<vci_param_int,
95                                         dspin_cmd_width,
96                                         dspin_rsp_width,
97                                         mips_iss >(
98                      sproc.str().c_str(),
99                      global_proc_id,                 // GLOBAL PROC_ID
100                      mtd,                            // Mapping Table
101                      IntTab(cluster_xy,p),           // SRCID
102                      global_cc_id,                   // GLOBAL_CC_ID
103                      8,                              // ITLB ways
104                      8,                              // ITLB sets
105                      8,                              // DTLB ways
106                      8,                              // DTLB sets
107                      l1_i_ways,l1_i_sets, 16,        // ICACHE size
108                      l1_d_ways,l1_d_sets, 16,        // DCACHE size
109                      4,                              // WBUF nlines
110                      4,                              // WBUF nwords
111                      x_width,
112                      y_width,
113                      frozen_cycles,                  // max frozen cycles
114                      trace_start_cycle,
115                      trace_ok );
116
117        std::ostringstream swip;
118        swip << "wi_proc_" << x_id << "_" << y_id << "_" << p;
119        wi_proc[p] = new VciDspinInitiatorWrapper<vci_param_int,
120                                                  dspin_cmd_width,
121                                                  dspin_rsp_width>(
122                     swip.str().c_str(),
123                     x_width + y_width + l_width);
124    }
125
126    /////////////////////////////////////////////////////////////////////////////
127    bool trace_ok = trace_memc_ok and (trace_memc_id == cluster_xy);
128    std::ostringstream smemc;
129    smemc << "memc_" << x_id << "_" << y_id;
130    memc = new VciMemCache<vci_param_int,
131                           vci_param_ext,
132                           dspin_rsp_width,
133                           dspin_cmd_width>(
134                     smemc.str().c_str(),
135                     mtd,                                // Mapping Table direct space
136                     mtx,                                // Mapping Table external space
137                     IntTab(cluster_xy),                 // SRCID external space
138                     IntTab(cluster_xy, tgtid_memc),     // TGTID direct space
139                     x_width,                            // Number of x bits in platform
140                     y_width,                            // Number of y bits in platform
141                     memc_ways, memc_sets, 16,           // CACHE SIZE
142                     3,                                  // MAX NUMBER OF COPIES
143                     4096,                               // HEAP SIZE
144                     8,                                  // TRANSACTION TABLE DEPTH
145                     8,                                  // UPDATE TABLE DEPTH
146                     8,                                  // INVALIDATE TABLE DEPTH
147                     trace_start_cycle,
148                     trace_ok );
149
150    wt_memc = new VciDspinTargetWrapper<vci_param_int,
151                                        dspin_cmd_width,
152                                        dspin_rsp_width>(
153                     "wt_memc",
154                     x_width + y_width + l_width);
155
156    /////////////////////////////////////////////////////////////////////////////
157    std::ostringstream sxram;
158    sxram << "xram_" << x_id << "_" << y_id;
159    xram = new VciSimpleRam<vci_param_ext>(
160                     sxram.str().c_str(),
161                     IntTab(cluster_xy),
162                     mtx,
163                     loader,
164                     xram_latency);
165
166    /////////////////////////////////////////////////////////////////////////////
167    std::ostringstream sxicu;
168    sxicu << "xicu_" << x_id << "_" << y_id;
169    xicu = new VciXicu<vci_param_int>(
170                     sxicu.str().c_str(),
171                     mtd,                               // mapping table
172                     IntTab(cluster_xy, tgtid_xicu),    // TGTID_D
173                     16,                                // number of timer IRQs
174                     16,                                // number of hard IRQs
175                     16,                                // number of soft IRQs
176                     16 );                              // number of output IRQs
177
178    wt_xicu = new VciDspinTargetWrapper<vci_param_int,
179                                        dspin_cmd_width,
180                                        dspin_rsp_width>(
181                     "wt_xicu",
182                     x_width + y_width + l_width);
183
184    /////////////////////////////////////////////////////////////////////////////
185    size_t nb_initiators = nb_procs;
186    size_t nb_targets    = 2;
187
188    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
189    {
190        nb_initiators = nb_procs + 1;
191        nb_targets    = 4;
192    }
193
194    std::ostringstream s_xbar_cmd;
195    s_xbar_cmd << "xbar_cmd_" << x_id << "_" << y_id;
196    xbar_cmd = new DspinLocalCrossbar<dspin_cmd_width>(
197                     s_xbar_cmd.str().c_str(),
198                     mtd,                          // mapping table
199                     x_id, y_id,                   // cluster coordinates
200                     x_width, y_width, l_width,
201                     nb_initiators,                // number of local of sources
202                     nb_targets,                   // number of local dests
203                     2, 2,                         // fifo depths 
204                     true,                         // CMD
205                     true,                         // use local routing table
206                     false );                      // no broadcast
207
208    /////////////////////////////////////////////////////////////////////////////
209    std::ostringstream s_xbar_rsp;
210    s_xbar_rsp << "xbar_rsp_" << x_id << "_" << y_id;
211    xbar_rsp = new DspinLocalCrossbar<dspin_rsp_width>(
212                     s_xbar_rsp.str().c_str(),
213                     mtd,                          // mapping table
214                     x_id, y_id,                   // cluster coordinates
215                     x_width, y_width, l_width,
216                     nb_targets,                   // number of local sources
217                     nb_initiators,                // number of local dests
218                     2, 2,                         // fifo depths 
219                     false,                        // RSP
220                     false,                        // don't use local routing table
221                     false );                      // no broadcast
222
223    /////////////////////////////////////////////////////////////////////////////
224    std::ostringstream s_xbar_m2p;
225    s_xbar_m2p << "xbar_m2p_" << x_id << "_" << y_id;
226    xbar_m2p = new DspinLocalCrossbar<dspin_cmd_width>(
227                     s_xbar_m2p.str().c_str(),
228                     mtd,                          // mapping table
229                     x_id, y_id,                   // cluster coordinates
230                     x_width, y_width, l_width,
231                     1,                            // number of local sources
232                     nb_procs,                     // number of local dests
233                     2, 2,                         // fifo depths
234                     true,                         // CMD
235                     false,                        // don't use local routing table
236                     true );                       // broadcast
237
238    /////////////////////////////////////////////////////////////////////////////
239    std::ostringstream s_xbar_p2m;
240    s_xbar_p2m << "xbar_p2m_" << x_id << "_" << y_id;
241    xbar_p2m = new DspinLocalCrossbar<dspin_rsp_width>(
242                     s_xbar_p2m.str().c_str(),
243                     mtd,                          // mapping table
244                     x_id, y_id,                   // cluster coordinates
245                     x_width, y_width, 0,          // l_width unused on p2m network
246                     nb_procs,                     // number of local sources
247                     1,                            // number of local dests
248                     2, 2,                         // fifo depths
249                     false,                        // RSP
250                     false,                        // don't use local routing table
251                     false );                      // no broadcast
252
253    /////////////////////////////////////////////////////////////////////////////
254    std::ostringstream s_xbar_cla;
255    s_xbar_cla << "xbar_cla_" << x_id << "_" << y_id;
256    xbar_cla = new DspinLocalCrossbar<dspin_cmd_width>(
257                     s_xbar_cla.str().c_str(),
258                     mtd,                          // mapping table
259                     x_id, y_id,                   // cluster coordinates
260                     x_width, y_width, l_width,
261                     1,                            // number of local sources
262                     nb_procs,                     // number of local dests
263                     2, 2,                         // fifo depths
264                     true,                         // CMD
265                     false,                        // don't use local routing table
266                     false);                       // no broadcast
267
268    /////////////////////////////////////////////////////////////////////////////
269    std::ostringstream s_router_cmd;
270    s_router_cmd << "router_cmd_" << x_id << "_" << y_id;
271    router_cmd = new DspinRouter<dspin_cmd_width>(
272                     s_router_cmd.str().c_str(),
273                     x_id,y_id,                    // coordinate in the mesh
274                     x_width, y_width,             // x & y fields width
275                     4,4);                         // input & output fifo depths
276
277    /////////////////////////////////////////////////////////////////////////////
278    std::ostringstream s_router_rsp;
279    s_router_rsp << "router_rsp_" << x_id << "_" << y_id;
280    router_rsp = new DspinRouter<dspin_rsp_width>(
281                     s_router_rsp.str().c_str(),
282                     x_id,y_id,                    // coordinates in mesh
283                     x_width, y_width,             // x & y fields width
284                     4,4);                         // input & output fifo depths
285
286    /////////////////////////////////////////////////////////////////////////////
287    std::ostringstream s_router_m2p;
288    s_router_m2p << "router_m2p_" << x_id << "_" << y_id;
289    router_m2p = new DspinRouter<dspin_cmd_width>(
290                     s_router_m2p.str().c_str(),
291                     x_id,y_id,                    // coordinate in the mesh
292                     x_width, y_width,             // x & y fields width
293                     4,4,                          // input & output fifo depths
294                     true);                        // broadcast supported
295
296    /////////////////////////////////////////////////////////////////////////////
297    std::ostringstream s_router_p2m;
298    s_router_p2m << "router_p2m_" << x_id << "_" << y_id;
299    router_p2m = new DspinRouter<dspin_rsp_width>(
300                     s_router_p2m.str().c_str(),
301                     x_id,y_id,                    // coordinates in mesh
302                     x_width, y_width,             // x & y fields width
303                     4,4);                         // input & output fifo depths
304
305    /////////////////////////////////////////////////////////////////////////////
306    std::ostringstream s_router_cla;
307    s_router_cla << "router_cla_" << x_id << "_" << y_id;
308    router_cla = new DspinRouter<dspin_cmd_width>(
309                     s_router_cla.str().c_str(),
310                     x_id,y_id,                    // coordinate in the mesh
311                     x_width, y_width,             // x & y fields width
312                     4,4);                         // input & output fifo depths
313
314    // backup BDV and TTY peripherals in cluster(0,0)
315    if ((x_id == 0) and (y_id == 0))
316    {
317        /////////////////////////////////////////////
318        bdev = new VciBlockDeviceTsar<vci_param_int>(
319                     "bdev",
320                     mtd,
321                     IntTab(cluster_xy, nb_procs),
322                     IntTab(cluster_xy, tgtid_bdev),
323                     disk_pathname,
324                     512,
325                     64 );            // burst size
326
327        wt_bdev = new VciDspinTargetWrapper<vci_param_int,
328                                            dspin_cmd_width,
329                                            dspin_rsp_width>(
330                     "wt_bdev",
331                     x_width + y_width + l_width);
332
333        wi_bdev = new VciDspinInitiatorWrapper<vci_param_int,
334                                               dspin_cmd_width,
335                                               dspin_rsp_width>(
336                     "wi_bdev",
337                     x_width + y_width + l_width);
338
339        /////////////////////////////////////////////
340        mtty = new VciMultiTty<vci_param_int>(
341                     "mtty",
342                     IntTab(cluster_xy, tgtid_mtty),
343                     mtd,
344                     "backup", NULL );
345
346        wt_mtty = new VciDspinTargetWrapper<vci_param_int,
347                                            dspin_cmd_width,
348                                            dspin_rsp_width>(
349                     "wt_mtty",
350                     x_width + y_width + l_width);
351    }
352
353    std::cout << std::endl;
354
355    ////////////////////////////////////
356    // Connections are defined here
357    ////////////////////////////////////
358
359    //////////////////////// ROUTERS
360    router_cmd->p_clk                      (this->p_clk);
361    router_cmd->p_resetn                   (this->p_resetn);
362    router_rsp->p_clk                      (this->p_clk);
363    router_rsp->p_resetn                   (this->p_resetn);
364    router_m2p->p_clk                      (this->p_clk);
365    router_m2p->p_resetn                   (this->p_resetn);
366    router_p2m->p_clk                      (this->p_clk);
367    router_p2m->p_resetn                   (this->p_resetn);
368    router_cla->p_clk                      (this->p_clk);
369    router_cla->p_resetn                   (this->p_resetn);
370
371    // loop on N/S/E/W ports
372    for (size_t i = 0; i < 4; i++)
373    {
374        router_cmd->p_out[i]               (this->p_cmd_out[i]);
375        router_cmd->p_in[i]                (this->p_cmd_in[i]);
376
377        router_rsp->p_out[i]               (this->p_rsp_out[i]);
378        router_rsp->p_in[i]                (this->p_rsp_in[i]);
379
380        router_m2p->p_out[i]               (this->p_m2p_out[i]);
381        router_m2p->p_in[i]                (this->p_m2p_in[i]);
382
383        router_p2m->p_out[i]               (this->p_p2m_out[i]);
384        router_p2m->p_in[i]                (this->p_p2m_in[i]);
385
386        router_cla->p_out[i]               (this->p_cla_out[i]);
387        router_cla->p_in[i]                (this->p_cla_in[i]);
388    }
389
390    router_cmd->p_out[4]                   (signal_dspin_cmd_g2l_d);
391    router_cmd->p_in[4]                    (signal_dspin_cmd_l2g_d);
392
393    router_rsp->p_out[4]                   (signal_dspin_rsp_g2l_d);
394    router_rsp->p_in[4]                    (signal_dspin_rsp_l2g_d);
395
396    router_m2p->p_out[4]                   (signal_dspin_m2p_g2l_c);
397    router_m2p->p_in[4]                    (signal_dspin_m2p_l2g_c);
398
399    router_p2m->p_out[4]                   (signal_dspin_p2m_g2l_c);
400    router_p2m->p_in[4]                    (signal_dspin_p2m_l2g_c);
401
402    router_cla->p_out[4]                   (signal_dspin_clack_g2l_c);
403    router_cla->p_in[4]                    (signal_dspin_clack_l2g_c);
404
405    std::cout << "  - routers connected" << std::endl;
406
407    ///////////////////// CMD DSPIN  local crossbar direct
408    xbar_cmd->p_clk                            (this->p_clk);
409    xbar_cmd->p_resetn                         (this->p_resetn);
410    xbar_cmd->p_global_out                     (signal_dspin_cmd_l2g_d);
411    xbar_cmd->p_global_in                      (signal_dspin_cmd_g2l_d);
412
413    xbar_cmd->p_local_out[tgtid_memc]          (signal_dspin_cmd_memc_t);
414    xbar_cmd->p_local_out[tgtid_xicu]          (signal_dspin_cmd_xicu_t);
415
416    for (size_t p = 0; p < nb_procs; p++)
417        xbar_cmd->p_local_in[p]                (signal_dspin_cmd_proc_i[p]);
418
419    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
420    {
421        xbar_cmd->p_local_out[tgtid_mtty]      (signal_dspin_cmd_mtty_t);
422        xbar_cmd->p_local_out[tgtid_bdev]      (signal_dspin_cmd_bdev_t);
423
424        xbar_cmd->p_local_in[nb_procs]         (signal_dspin_cmd_bdev_i);
425    }
426
427    std::cout << "  - CMD Direct crossbar connected" << std::endl;
428
429    //////////////////////// RSP DSPIN  local crossbar direct
430    xbar_rsp->p_clk                            (this->p_clk);
431    xbar_rsp->p_resetn                         (this->p_resetn);
432    xbar_rsp->p_global_out                     (signal_dspin_rsp_l2g_d);
433    xbar_rsp->p_global_in                      (signal_dspin_rsp_g2l_d);
434
435    xbar_rsp->p_local_in[tgtid_memc]           (signal_dspin_rsp_memc_t);
436    xbar_rsp->p_local_in[tgtid_xicu]           (signal_dspin_rsp_xicu_t);
437
438    for (size_t p = 0; p < nb_procs; p++)
439        xbar_rsp->p_local_out[p]               (signal_dspin_rsp_proc_i[p]);
440
441    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
442    {
443        xbar_rsp->p_local_in[tgtid_mtty]       (signal_dspin_rsp_mtty_t);
444        xbar_rsp->p_local_in[tgtid_bdev]       (signal_dspin_rsp_bdev_t);
445
446        xbar_rsp->p_local_out[nb_procs]        (signal_dspin_rsp_bdev_i);
447    }
448
449    std::cout << "  - RSP Direct crossbar connected" << std::endl;
450
451    ////////////////////// M2P DSPIN local crossbar coherence
452    xbar_m2p->p_clk                            (this->p_clk);
453    xbar_m2p->p_resetn                         (this->p_resetn);
454    xbar_m2p->p_global_out                     (signal_dspin_m2p_l2g_c);
455    xbar_m2p->p_global_in                      (signal_dspin_m2p_g2l_c);
456    xbar_m2p->p_local_in[0]                    (signal_dspin_m2p_memc);
457    for (size_t p = 0; p < nb_procs; p++)
458        xbar_m2p->p_local_out[p]               (signal_dspin_m2p_proc[p]);
459
460    std::cout << "  - M2P Coherence crossbar connected" << std::endl;
461
462    ////////////////////////// P2M DSPIN local crossbar coherence
463    xbar_p2m->p_clk                            (this->p_clk);
464    xbar_p2m->p_resetn                         (this->p_resetn);
465    xbar_p2m->p_global_out                     (signal_dspin_p2m_l2g_c);
466    xbar_p2m->p_global_in                      (signal_dspin_p2m_g2l_c);
467    xbar_p2m->p_local_out[0]                   (signal_dspin_p2m_memc);
468    for (size_t p = 0; p < nb_procs; p++)
469        xbar_p2m->p_local_in[p]                (signal_dspin_p2m_proc[p]);
470
471    std::cout << "  - P2M Coherence crossbar connected" << std::endl;
472
473    ////////////////////// CLACK DSPIN local crossbar coherence
474    xbar_cla->p_clk                          (this->p_clk);
475    xbar_cla->p_resetn                       (this->p_resetn);
476    xbar_cla->p_global_out                   (signal_dspin_clack_l2g_c);
477    xbar_cla->p_global_in                    (signal_dspin_clack_g2l_c);
478    xbar_cla->p_local_in[0]                  (signal_dspin_clack_memc);
479    for (size_t p = 0; p < nb_procs; p++)
480        xbar_cla->p_local_out[p]             (signal_dspin_clack_proc[p]);
481
482    std::cout << "  - CLA Coherence crossbar connected" << std::endl;
483
484    //////////////////////////////////// Processors
485    for (size_t p = 0; p < nb_procs; p++)
486    {
487        proc[p]->p_clk                      (this->p_clk);
488        proc[p]->p_resetn                   (this->p_resetn);
489        proc[p]->p_vci                      (signal_vci_ini_proc[p]);
490        proc[p]->p_dspin_m2p                (signal_dspin_m2p_proc[p]);
491        proc[p]->p_dspin_p2m                (signal_dspin_p2m_proc[p]);
492        proc[p]->p_dspin_clack              (signal_dspin_clack_proc[p]);
493
494        for ( size_t j = 0 ; j < 6 ; j++)
495        {
496            if ( j < 4 ) proc[p]->p_irq[j]  (signal_proc_irq[4*p + j]);
497            else         proc[p]->p_irq[j]  (signal_false);
498        }
499
500        wi_proc[p]->p_clk                   (this->p_clk);
501        wi_proc[p]->p_resetn                (this->p_resetn);
502        wi_proc[p]->p_dspin_cmd             (signal_dspin_cmd_proc_i[p]);
503        wi_proc[p]->p_dspin_rsp             (signal_dspin_rsp_proc_i[p]);
504        wi_proc[p]->p_vci                   (signal_vci_ini_proc[p]);
505    }
506
507    std::cout << "  - Processors connected" << std::endl;
508
509    ///////////////////////////////////// XICU
510    xicu->p_clk                        (this->p_clk);
511    xicu->p_resetn                     (this->p_resetn);
512    xicu->p_vci                        (signal_vci_tgt_xicu);
513
514    for (size_t i = 0 ; i < 16  ; i++)
515    {
516        xicu->p_irq[i]                 (signal_proc_irq[i]);
517    }
518
519    for (size_t i = 0; i < 16; i++)
520    {
521        if ((x_id == 0) and (y_id == 0)) // cluster (0,0)
522        {
523            if      (i == 8)           xicu->p_hwi[i] (signal_irq_memc);
524            else if (i == 9)           xicu->p_hwi[i] (signal_irq_bdev);
525            else if (i == 10)          xicu->p_hwi[i] (signal_irq_mtty);
526            else                       xicu->p_hwi[i] (signal_false);
527        }
528        else                             // other clusters
529        {
530            if (i == 1)                xicu->p_hwi[i] (signal_irq_memc);
531            else                       xicu->p_hwi[i] (signal_false);
532        }
533    }
534
535    // wrapper XICU
536    wt_xicu->p_clk                     (this->p_clk);
537    wt_xicu->p_resetn                  (this->p_resetn);
538    wt_xicu->p_dspin_cmd               (signal_dspin_cmd_xicu_t);
539    wt_xicu->p_dspin_rsp               (signal_dspin_rsp_xicu_t);
540    wt_xicu->p_vci                     (signal_vci_tgt_xicu);
541
542    std::cout << "  - XICU connected" << std::endl;
543
544    //////////////////////////////////////////////// MEMC
545    memc->p_clk                        (this->p_clk);
546    memc->p_resetn                     (this->p_resetn);
547    memc->p_irq                        (signal_irq_memc);
548    memc->p_vci_ixr                    (signal_vci_xram);
549    memc->p_vci_tgt                    (signal_vci_tgt_memc);
550    memc->p_dspin_p2m                  (signal_dspin_p2m_memc);
551    memc->p_dspin_m2p                  (signal_dspin_m2p_memc);
552    memc->p_dspin_clack                (signal_dspin_clack_memc);
553
554    // wrapper MEMC
555    wt_memc->p_clk                     (this->p_clk);
556    wt_memc->p_resetn                  (this->p_resetn);
557    wt_memc->p_dspin_cmd               (signal_dspin_cmd_memc_t);
558    wt_memc->p_dspin_rsp               (signal_dspin_rsp_memc_t);
559    wt_memc->p_vci                     (signal_vci_tgt_memc);
560
561    std::cout << "  - MEMC connected" << std::endl;
562
563    /////////////////////////////////////////////// XRAM
564    xram->p_clk                        (this->p_clk);
565    xram->p_resetn                     (this->p_resetn);
566    xram->p_vci                        (signal_vci_xram);
567
568    std::cout << "  - XRAM connected" << std::endl;
569
570    /////////////////////////////// Extra Components in cluster(0,0)
571
572    if ((x_id == 0) and (y_id == 0))
573    {
574        // BDEV
575        bdev->p_clk                    (this->p_clk);
576        bdev->p_resetn                 (this->p_resetn);
577        bdev->p_irq                    (signal_irq_bdev);
578        bdev->p_vci_target             (signal_vci_tgt_bdev);
579        bdev->p_vci_initiator          (signal_vci_ini_bdev);
580
581        // wrapper tgt BDEV
582        wt_bdev->p_clk                 (this->p_clk);
583        wt_bdev->p_resetn              (this->p_resetn);
584        wt_bdev->p_dspin_cmd           (signal_dspin_cmd_bdev_t);
585        wt_bdev->p_dspin_rsp           (signal_dspin_rsp_bdev_t);
586        wt_bdev->p_vci                 (signal_vci_tgt_bdev);
587
588        // wrapper ini BDEV
589        wi_bdev->p_clk                 (this->p_clk);
590        wi_bdev->p_resetn              (this->p_resetn);
591        wi_bdev->p_dspin_cmd           (signal_dspin_cmd_bdev_i);
592        wi_bdev->p_dspin_rsp           (signal_dspin_rsp_bdev_i);
593        wi_bdev->p_vci                 (signal_vci_ini_bdev);
594
595        std::cout << "  - BDEV connected" << std::endl;
596
597        // MTTY (single channel)
598        mtty->p_clk                    (this->p_clk);
599        mtty->p_resetn                 (this->p_resetn);
600        mtty->p_vci                    (signal_vci_tgt_mtty);
601        mtty->p_irq[0]                 (signal_irq_mtty);
602
603        // wrapper tgt MTTY
604        wt_mtty->p_clk                 (this->p_clk);
605        wt_mtty->p_resetn              (this->p_resetn);
606        wt_mtty->p_dspin_cmd           (signal_dspin_cmd_mtty_t);
607        wt_mtty->p_dspin_rsp           (signal_dspin_rsp_mtty_t);
608        wt_mtty->p_vci                 (signal_vci_tgt_mtty);
609
610        std::cout << "  - MTTY connected" << std::endl;
611    }
612} // end constructor
613
614
615
616template<size_t dspin_cmd_width,
617         size_t dspin_rsp_width,
618         typename vci_param_int,
619         typename vci_param_ext> TsarLetiCluster<dspin_cmd_width,
620                                                 dspin_rsp_width,
621                                                 vci_param_int,
622                                                 vci_param_ext>::~TsarLetiCluster() {
623
624    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cmd_in, 4);
625    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cmd_out, 4);
626
627    dealloc_elems<DspinInput<dspin_rsp_width> > (p_rsp_in, 4);
628    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_rsp_out, 4);
629
630    dealloc_elems<DspinInput<dspin_cmd_width> > (p_m2p_in, 4);
631    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_m2p_out, 4);
632
633    dealloc_elems<DspinInput<dspin_rsp_width> > (p_p2m_in, 4);
634    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_p2m_out, 4);
635
636    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cla_in, 4);
637    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cla_out, 4);
638
639    for (size_t p = 0; p < 4 ; p++)
640    {
641        if ( proc[p] )     delete proc[p];
642        if ( wi_proc[p] )  delete wi_proc[p];
643    }
644
645    delete memc;
646    delete wt_memc;
647    delete xram;
648    delete xicu;
649    delete wt_xicu;
650    delete xbar_cmd;
651    delete xbar_rsp;
652    delete xbar_m2p;
653    delete xbar_p2m;
654    delete xbar_cla;
655    delete router_cmd;
656    delete router_rsp;
657    delete router_m2p;
658    delete router_p2m;
659    delete router_cla;
660
661    if ( bdev )
662    {
663        delete bdev;
664        delete wt_bdev;
665        delete wi_bdev;
666    }
667
668    if ( mtty )
669    {
670        delete mtty;
671        delete wt_mtty;
672    }
673}
674
675
676}}
677
678// Local Variables:
679// tab-width: 4
680// c-basic-offset: 4
681// c-file-offsets:((innamespace . 0)(inline-open . 0))
682// indent-tabs-mode: nil
683// End:
684
685// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
686
687
688
Note: See TracBrowser for help on using the repository browser.