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

Last change on this file since 628 was 628, checked in by alain, 9 years ago

Introducing the vci_iopic component in the tsar_generic_leti plat-form.
This platform has been tested wit three distributed applications
running on top of the giet_tsar:

  • soft_hello_giet
  • soft_transpose_giet
  • soft_sort_giet
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    if ((x_id == 0) and (y_id == 0))
315    {
316        /////////////////////////////////////////////
317        bdev = new VciBlockDeviceTsar<vci_param_int>(
318                     "bdev",
319                     mtd,
320                     IntTab(cluster_xy, nb_procs),
321                     IntTab(cluster_xy, tgtid_bdev),
322                     disk_pathname,
323                     512,
324                     64 );            // burst size
325
326        wt_bdev = new VciDspinTargetWrapper<vci_param_int,
327                                            dspin_cmd_width,
328                                            dspin_rsp_width>(
329                     "wt_bdev",
330                     x_width + y_width + l_width);
331
332        wi_bdev = new VciDspinInitiatorWrapper<vci_param_int,
333                                               dspin_cmd_width,
334                                               dspin_rsp_width>(
335                     "wi_bdev",
336                     x_width + y_width + l_width);
337
338        /////////////////////////////////////////////
339        mtty = new VciMultiTty<vci_param_int>(
340                     "mtty",
341                     IntTab(cluster_xy, tgtid_mtty),
342                     mtd,
343                     "tty_0_0", NULL );
344
345        wt_mtty = new VciDspinTargetWrapper<vci_param_int,
346                                            dspin_cmd_width,
347                                            dspin_rsp_width>(
348                     "wt_mtty",
349                     x_width + y_width + l_width);
350    }
351
352    std::cout << std::endl;
353
354    ////////////////////////////////////
355    // Connections are defined here
356    ////////////////////////////////////
357
358    //////////////////////// ROUTERS
359    router_cmd->p_clk                      (this->p_clk);
360    router_cmd->p_resetn                   (this->p_resetn);
361    router_rsp->p_clk                      (this->p_clk);
362    router_rsp->p_resetn                   (this->p_resetn);
363    router_m2p->p_clk                      (this->p_clk);
364    router_m2p->p_resetn                   (this->p_resetn);
365    router_p2m->p_clk                      (this->p_clk);
366    router_p2m->p_resetn                   (this->p_resetn);
367    router_cla->p_clk                      (this->p_clk);
368    router_cla->p_resetn                   (this->p_resetn);
369
370    // loop on N/S/E/W ports
371    for (size_t i = 0; i < 4; i++)
372    {
373        router_cmd->p_out[i]               (this->p_cmd_out[i]);
374        router_cmd->p_in[i]                (this->p_cmd_in[i]);
375
376        router_rsp->p_out[i]               (this->p_rsp_out[i]);
377        router_rsp->p_in[i]                (this->p_rsp_in[i]);
378
379        router_m2p->p_out[i]               (this->p_m2p_out[i]);
380        router_m2p->p_in[i]                (this->p_m2p_in[i]);
381
382        router_p2m->p_out[i]               (this->p_p2m_out[i]);
383        router_p2m->p_in[i]                (this->p_p2m_in[i]);
384
385        router_cla->p_out[i]               (this->p_cla_out[i]);
386        router_cla->p_in[i]                (this->p_cla_in[i]);
387    }
388
389    router_cmd->p_out[4]                   (signal_dspin_cmd_g2l_d);
390    router_cmd->p_in[4]                    (signal_dspin_cmd_l2g_d);
391
392    router_rsp->p_out[4]                   (signal_dspin_rsp_g2l_d);
393    router_rsp->p_in[4]                    (signal_dspin_rsp_l2g_d);
394
395    router_m2p->p_out[4]                   (signal_dspin_m2p_g2l_c);
396    router_m2p->p_in[4]                    (signal_dspin_m2p_l2g_c);
397
398    router_p2m->p_out[4]                   (signal_dspin_p2m_g2l_c);
399    router_p2m->p_in[4]                    (signal_dspin_p2m_l2g_c);
400
401    router_cla->p_out[4]                   (signal_dspin_clack_g2l_c);
402    router_cla->p_in[4]                    (signal_dspin_clack_l2g_c);
403
404    std::cout << "  - routers connected" << std::endl;
405
406    ///////////////////// CMD DSPIN  local crossbar direct
407    xbar_cmd->p_clk                            (this->p_clk);
408    xbar_cmd->p_resetn                         (this->p_resetn);
409    xbar_cmd->p_global_out                     (signal_dspin_cmd_l2g_d);
410    xbar_cmd->p_global_in                      (signal_dspin_cmd_g2l_d);
411
412    xbar_cmd->p_local_out[tgtid_memc]          (signal_dspin_cmd_memc_t);
413    xbar_cmd->p_local_out[tgtid_xicu]          (signal_dspin_cmd_xicu_t);
414
415    for (size_t p = 0; p < nb_procs; p++)
416        xbar_cmd->p_local_in[p]                (signal_dspin_cmd_proc_i[p]);
417
418    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
419    {
420        xbar_cmd->p_local_out[tgtid_mtty]      (signal_dspin_cmd_mtty_t);
421        xbar_cmd->p_local_out[tgtid_bdev]      (signal_dspin_cmd_bdev_t);
422
423        xbar_cmd->p_local_in[nb_procs]         (signal_dspin_cmd_bdev_i);
424    }
425
426    std::cout << "  - CMD Direct crossbar connected" << std::endl;
427
428    //////////////////////// RSP DSPIN  local crossbar direct
429    xbar_rsp->p_clk                            (this->p_clk);
430    xbar_rsp->p_resetn                         (this->p_resetn);
431    xbar_rsp->p_global_out                     (signal_dspin_rsp_l2g_d);
432    xbar_rsp->p_global_in                      (signal_dspin_rsp_g2l_d);
433
434    xbar_rsp->p_local_in[tgtid_memc]           (signal_dspin_rsp_memc_t);
435    xbar_rsp->p_local_in[tgtid_xicu]           (signal_dspin_rsp_xicu_t);
436
437    for (size_t p = 0; p < nb_procs; p++)
438        xbar_rsp->p_local_out[p]               (signal_dspin_rsp_proc_i[p]);
439
440    if ((x_id == 0) and (y_id == 0))  // cluster(0,0)
441    {
442        xbar_rsp->p_local_in[tgtid_mtty]       (signal_dspin_rsp_mtty_t);
443        xbar_rsp->p_local_in[tgtid_bdev]       (signal_dspin_rsp_bdev_t);
444
445        xbar_rsp->p_local_out[nb_procs]        (signal_dspin_rsp_bdev_i);
446    }
447
448    std::cout << "  - RSP Direct crossbar connected" << std::endl;
449
450    ////////////////////// M2P DSPIN local crossbar coherence
451    xbar_m2p->p_clk                            (this->p_clk);
452    xbar_m2p->p_resetn                         (this->p_resetn);
453    xbar_m2p->p_global_out                     (signal_dspin_m2p_l2g_c);
454    xbar_m2p->p_global_in                      (signal_dspin_m2p_g2l_c);
455    xbar_m2p->p_local_in[0]                    (signal_dspin_m2p_memc);
456    for (size_t p = 0; p < nb_procs; p++)
457        xbar_m2p->p_local_out[p]               (signal_dspin_m2p_proc[p]);
458
459    std::cout << "  - M2P Coherence crossbar connected" << std::endl;
460
461    ////////////////////////// P2M DSPIN local crossbar coherence
462    xbar_p2m->p_clk                            (this->p_clk);
463    xbar_p2m->p_resetn                         (this->p_resetn);
464    xbar_p2m->p_global_out                     (signal_dspin_p2m_l2g_c);
465    xbar_p2m->p_global_in                      (signal_dspin_p2m_g2l_c);
466    xbar_p2m->p_local_out[0]                   (signal_dspin_p2m_memc);
467    for (size_t p = 0; p < nb_procs; p++)
468        xbar_p2m->p_local_in[p]                (signal_dspin_p2m_proc[p]);
469
470    std::cout << "  - P2M Coherence crossbar connected" << std::endl;
471
472    ////////////////////// CLACK DSPIN local crossbar coherence
473    xbar_cla->p_clk                          (this->p_clk);
474    xbar_cla->p_resetn                       (this->p_resetn);
475    xbar_cla->p_global_out                   (signal_dspin_clack_l2g_c);
476    xbar_cla->p_global_in                    (signal_dspin_clack_g2l_c);
477    xbar_cla->p_local_in[0]                  (signal_dspin_clack_memc);
478    for (size_t p = 0; p < nb_procs; p++)
479        xbar_cla->p_local_out[p]             (signal_dspin_clack_proc[p]);
480
481    std::cout << "  - CLA Coherence crossbar connected" << std::endl;
482
483    //////////////////////////////////// Processors
484    for (size_t p = 0; p < nb_procs; p++)
485    {
486        proc[p]->p_clk                      (this->p_clk);
487        proc[p]->p_resetn                   (this->p_resetn);
488        proc[p]->p_vci                      (signal_vci_ini_proc[p]);
489        proc[p]->p_dspin_m2p                (signal_dspin_m2p_proc[p]);
490        proc[p]->p_dspin_p2m                (signal_dspin_p2m_proc[p]);
491        proc[p]->p_dspin_clack              (signal_dspin_clack_proc[p]);
492
493        for ( size_t j = 0 ; j < 6 ; j++)
494        {
495            if ( j < 4 ) proc[p]->p_irq[j]  (signal_proc_irq[4*p + j]);
496            else         proc[p]->p_irq[j]  (signal_false);
497        }
498
499        wi_proc[p]->p_clk                   (this->p_clk);
500        wi_proc[p]->p_resetn                (this->p_resetn);
501        wi_proc[p]->p_dspin_cmd             (signal_dspin_cmd_proc_i[p]);
502        wi_proc[p]->p_dspin_rsp             (signal_dspin_rsp_proc_i[p]);
503        wi_proc[p]->p_vci                   (signal_vci_ini_proc[p]);
504    }
505
506    std::cout << "  - Processors connected" << std::endl;
507
508    ///////////////////////////////////// XICU
509    xicu->p_clk                        (this->p_clk);
510    xicu->p_resetn                     (this->p_resetn);
511    xicu->p_vci                        (signal_vci_tgt_xicu);
512
513    for (size_t i = 0 ; i < 16  ; i++)
514    {
515        xicu->p_irq[i]                 (signal_proc_irq[i]);
516    }
517
518    for (size_t i = 0; i < 16; i++)
519    {
520        if ((x_id == 0) and (y_id == 0)) // cluster (0,0)
521        {
522            if      (i == 8)           xicu->p_hwi[i] (signal_irq_memc);
523            else if (i == 9)           xicu->p_hwi[i] (signal_irq_bdev);
524            else if (i == 10)          xicu->p_hwi[i] (signal_irq_mtty);
525            else                       xicu->p_hwi[i] (signal_false);
526        }
527        else                             // other clusters
528        {
529            if (i == 1)                xicu->p_hwi[i] (signal_irq_memc);
530            else                       xicu->p_hwi[i] (signal_false);
531        }
532    }
533
534    // wrapper XICU
535    wt_xicu->p_clk                     (this->p_clk);
536    wt_xicu->p_resetn                  (this->p_resetn);
537    wt_xicu->p_dspin_cmd               (signal_dspin_cmd_xicu_t);
538    wt_xicu->p_dspin_rsp               (signal_dspin_rsp_xicu_t);
539    wt_xicu->p_vci                     (signal_vci_tgt_xicu);
540
541    std::cout << "  - XICU connected" << std::endl;
542
543    //////////////////////////////////////////////// MEMC
544    memc->p_clk                        (this->p_clk);
545    memc->p_resetn                     (this->p_resetn);
546    memc->p_irq                        (signal_irq_memc);
547    memc->p_vci_ixr                    (signal_vci_xram);
548    memc->p_vci_tgt                    (signal_vci_tgt_memc);
549    memc->p_dspin_p2m                  (signal_dspin_p2m_memc);
550    memc->p_dspin_m2p                  (signal_dspin_m2p_memc);
551    memc->p_dspin_clack                (signal_dspin_clack_memc);
552
553    // wrapper MEMC
554    wt_memc->p_clk                     (this->p_clk);
555    wt_memc->p_resetn                  (this->p_resetn);
556    wt_memc->p_dspin_cmd               (signal_dspin_cmd_memc_t);
557    wt_memc->p_dspin_rsp               (signal_dspin_rsp_memc_t);
558    wt_memc->p_vci                     (signal_vci_tgt_memc);
559
560    std::cout << "  - MEMC connected" << std::endl;
561
562    /////////////////////////////////////////////// XRAM
563    xram->p_clk                        (this->p_clk);
564    xram->p_resetn                     (this->p_resetn);
565    xram->p_vci                        (signal_vci_xram);
566
567    std::cout << "  - XRAM connected" << std::endl;
568
569    /////////////////////////////// Extra Components in cluster(0,0)
570
571    if ((x_id == 0) and (y_id == 0))
572    {
573        // BDEV
574        bdev->p_clk                    (this->p_clk);
575        bdev->p_resetn                 (this->p_resetn);
576        bdev->p_irq                    (signal_irq_bdev);
577        bdev->p_vci_target             (signal_vci_tgt_bdev);
578        bdev->p_vci_initiator          (signal_vci_ini_bdev);
579
580        // wrapper tgt BDEV
581        wt_bdev->p_clk                 (this->p_clk);
582        wt_bdev->p_resetn              (this->p_resetn);
583        wt_bdev->p_dspin_cmd           (signal_dspin_cmd_bdev_t);
584        wt_bdev->p_dspin_rsp           (signal_dspin_rsp_bdev_t);
585        wt_bdev->p_vci                 (signal_vci_tgt_bdev);
586
587        // wrapper ini BDEV
588        wi_bdev->p_clk                 (this->p_clk);
589        wi_bdev->p_resetn              (this->p_resetn);
590        wi_bdev->p_dspin_cmd           (signal_dspin_cmd_bdev_i);
591        wi_bdev->p_dspin_rsp           (signal_dspin_rsp_bdev_i);
592        wi_bdev->p_vci                 (signal_vci_ini_bdev);
593
594        std::cout << "  - BDEV connected" << std::endl;
595
596        // MTTY (single channel)
597        mtty->p_clk                    (this->p_clk);
598        mtty->p_resetn                 (this->p_resetn);
599        mtty->p_vci                    (signal_vci_tgt_mtty);
600        mtty->p_irq[0]                 (signal_irq_mtty);
601
602        // wrapper tgt MTTY
603        wt_mtty->p_clk                 (this->p_clk);
604        wt_mtty->p_resetn              (this->p_resetn);
605        wt_mtty->p_dspin_cmd           (signal_dspin_cmd_mtty_t);
606        wt_mtty->p_dspin_rsp           (signal_dspin_rsp_mtty_t);
607        wt_mtty->p_vci                 (signal_vci_tgt_mtty);
608
609        std::cout << "  - MTTY connected" << std::endl;
610    }
611} // end constructor
612
613
614
615template<size_t dspin_cmd_width,
616         size_t dspin_rsp_width,
617         typename vci_param_int,
618         typename vci_param_ext> TsarLetiCluster<dspin_cmd_width,
619                                                 dspin_rsp_width,
620                                                 vci_param_int,
621                                                 vci_param_ext>::~TsarLetiCluster() {
622
623    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cmd_in, 4);
624    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cmd_out, 4);
625
626    dealloc_elems<DspinInput<dspin_rsp_width> > (p_rsp_in, 4);
627    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_rsp_out, 4);
628
629    dealloc_elems<DspinInput<dspin_cmd_width> > (p_m2p_in, 4);
630    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_m2p_out, 4);
631
632    dealloc_elems<DspinInput<dspin_rsp_width> > (p_p2m_in, 4);
633    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_p2m_out, 4);
634
635    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cla_in, 4);
636    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cla_out, 4);
637
638    for (size_t p = 0; p < 4 ; p++)
639    {
640        if ( proc[p] )     delete proc[p];
641        if ( wi_proc[p] )  delete wi_proc[p];
642    }
643
644    delete memc;
645    delete wt_memc;
646    delete xram;
647    delete xicu;
648    delete wt_xicu;
649    delete xbar_cmd;
650    delete xbar_rsp;
651    delete xbar_m2p;
652    delete xbar_p2m;
653    delete xbar_cla;
654    delete router_cmd;
655    delete router_rsp;
656    delete router_m2p;
657    delete router_p2m;
658    delete router_cla;
659
660    if ( bdev )
661    {
662        delete bdev;
663        delete wt_bdev;
664        delete wi_bdev;
665    }
666
667    if ( mtty )
668    {
669        delete mtty;
670        delete wt_mtty;
671    }
672}
673
674
675}}
676
677// Local Variables:
678// tab-width: 4
679// c-basic-offset: 4
680// c-file-offsets:((innamespace . 0)(inline-open . 0))
681// indent-tabs-mode: nil
682// End:
683
684// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
685
686
687
Note: See TracBrowser for help on using the repository browser.