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

Last change on this file since 692 was 692, checked in by cfuguet, 10 years ago

tsar_generic_leti:

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