source: trunk/platforms/tsar_generic_xbar/tsar_xbar_cluster/caba/source/src/tsar_xbar_cluster.cpp @ 619

Last change on this file since 619 was 619, checked in by cfuguet, 9 years ago

Modifications in the tsar_generic_xbar platform to support
new cluster id encoding with X and Y fixed width format

File size: 39.0 KB
Line 
1//////////////////////////////////////////////////////////////////////////////
2// File: tsar_xbar_cluster.cpp
3// Author: Alain Greiner
4// Copyright: UPMC/LIP6
5// Date : march 2011
6// This program is released under the GNU public license
7//////////////////////////////////////////////////////////////////////////////
8// This file define a TSAR cluster architecture with virtual memory:
9// - It uses two virtual_dspin_router as distributed global interconnect
10// - It uses four dspin_local_crossbar as local interconnect
11// - It uses the vci_cc_vcache_wrapper
12// - It uses the vci_mem_cache
13// - It contains a private RAM with a variable latency to emulate the L3 cache
14// - It can contains 1, 2 or 4 processors
15// - Each processor has a private dma channel (vci_multi_dma)
16// - It uses the vci_xicu interrupt controller
17// - The peripherals MTTY, BDEV, FBUF, MNIC and BROM are in cluster (0,0)
18// - The Multi-TTY component controls up to 15 terminals.
19// - Each Multi-DMA component controls up to 8 DMA channels.
20// - The DMA IRQs are connected to IRQ_IN[8]...IRQ_IN[15]
21// - The TTY IRQs are connected to IRQ_IN[16]...IRQ_IN[30]
22// - The BDEV IRQ is connected to IRQ_IN[31]
23//////////////////////////////////////////////////////////////////////////////////
24
25#include "../include/tsar_xbar_cluster.h"
26
27
28namespace soclib {
29namespace caba  {
30
31////////////////////////////////////////////////////////////////////////////////////
32template<size_t dspin_cmd_width,
33         size_t dspin_rsp_width,
34         typename vci_param_int,
35         typename vci_param_ext> TsarXbarCluster<dspin_cmd_width,
36                                                 dspin_rsp_width,
37                                                 vci_param_int,
38                                                 vci_param_ext>::TsarXbarCluster(
39////////////////////////////////////////////////////////////////////////////////////
40         sc_module_name                     insname,
41         size_t                             nb_procs,
42         size_t                             nb_ttys,
43         size_t                             nb_dmas,
44         size_t                             x_id,
45         size_t                             y_id,
46         size_t                             cluster_id,
47         const soclib::common::MappingTable &mtd,
48         const soclib::common::MappingTable &mtx,
49         size_t                             x_width,
50         size_t                             y_width,
51         size_t                             l_width,
52         size_t                             tgtid_memc,
53         size_t                             tgtid_xicu,
54         size_t                             tgtid_mdma,
55         size_t                             tgtid_fbuf,
56         size_t                             tgtid_mtty,
57         size_t                             tgtid_brom,
58         size_t                             tgtid_mnic,
59         size_t                             tgtid_chbuf,
60         size_t                             tgtid_bdev,
61         size_t                             tgtid_simh,
62         size_t                             memc_ways,
63         size_t                             memc_sets,
64         size_t                             l1_i_ways,
65         size_t                             l1_i_sets,
66         size_t                             l1_d_ways,
67         size_t                             l1_d_sets,
68         size_t                             xram_latency,
69         bool                               io,
70         size_t                             xfb,
71         size_t                             yfb,
72         char*                              disk_name,
73         size_t                             block_size,
74         size_t                             nic_channels,
75         char*                              nic_rx_name,
76         char*                              nic_tx_name,
77         uint32_t                           nic_timeout,
78         size_t                             chbufdma_channels,
79         const Loader                      &loader,
80         uint32_t                           frozen_cycles,
81         uint32_t                           debug_start_cycle,
82         bool                               memc_debug_ok,
83         bool                               proc_debug_ok)
84            : soclib::caba::BaseModule(insname),
85            p_clk("clk"),
86            p_resetn("resetn")
87
88{
89
90    n_procs = nb_procs;
91
92    // Vectors of ports definition
93    p_cmd_in  = alloc_elems<DspinInput<dspin_cmd_width> >  ("p_cmd_in",  4, 3);
94    p_cmd_out = alloc_elems<DspinOutput<dspin_cmd_width> > ("p_cmd_out", 4, 3);
95    p_rsp_in  = alloc_elems<DspinInput<dspin_rsp_width> >  ("p_rsp_in",  4, 2);
96    p_rsp_out = alloc_elems<DspinOutput<dspin_rsp_width> > ("p_rsp_out", 4, 2);
97
98    /////////////////////////////////////////////////////////////////////////////
99    // Components definition
100    /////////////////////////////////////////////////////////////////////////////
101
102    for (size_t p = 0; p < nb_procs; p++)
103    {
104        std::ostringstream sproc;
105        sproc << "proc_" << x_id << "_" << y_id << "_" << p;
106        proc[p] = new VciCcVCacheWrapper<vci_param_int,
107                                         dspin_cmd_width,
108                                         dspin_rsp_width,
109                                         GdbServer<Mips32ElIss> >(
110                      sproc.str().c_str(),
111                      cluster_id * nb_procs + p,      // GLOBAL PROC_ID
112                      mtd,                            // Mapping Table
113                      IntTab(cluster_id,p),           // SRCID
114                      (cluster_id << l_width) + p,    // CC_GLOBAL_ID
115                      8,                              // ITLB ways
116                      8,                              // ITLB sets
117                      8,                              // DTLB ways
118                      8,                              // DTLB sets
119                      l1_i_ways,l1_i_sets, 16,        // ICACHE size
120                      l1_d_ways,l1_d_sets, 16,        // DCACHE size
121                      4,                              // WBUF nlines
122                      4,                              // WBUF nwords
123                      x_width,
124                      y_width,
125                      frozen_cycles,                  // max frozen cycles
126                      debug_start_cycle,
127                      proc_debug_ok);
128
129        std::ostringstream swip;
130        swip << "wi_proc_" << x_id << "_" << y_id << "_" << p;
131        wi_proc[p] = new VciDspinInitiatorWrapper<vci_param_int,
132                                                  dspin_cmd_width,
133                                                  dspin_rsp_width>(
134                     swip.str().c_str(),
135                     x_width + y_width + l_width);
136    }
137
138    /////////////////////////////////////////////////////////////////////////////
139    std::ostringstream smemc;
140    smemc << "memc_" << x_id << "_" << y_id;
141    memc = new VciMemCache<vci_param_int,
142                           vci_param_ext,
143                           dspin_rsp_width,
144                           dspin_cmd_width>(
145                     smemc.str().c_str(),
146                     mtd,                                // Mapping Table direct space
147                     mtx,                                // Mapping Table external space
148                     IntTab(cluster_id),                 // SRCID external space
149                     IntTab(cluster_id, tgtid_memc),     // TGTID direct space
150                     x_width,                            // Number of x bits in platform
151                     y_width,                            // Number of y bits in platform
152                     memc_ways, memc_sets, 16,           // CACHE SIZE
153                     3,                                  // MAX NUMBER OF COPIES
154                     4096,                               // HEAP SIZE
155                     8,                                  // TRANSACTION TABLE DEPTH
156                     8,                                  // UPDATE TABLE DEPTH
157                     8,                                  // INVALIDATE TABLE DEPTH
158                     debug_start_cycle,
159                     memc_debug_ok);
160
161    wt_memc = new VciDspinTargetWrapper<vci_param_int,
162                                        dspin_cmd_width,
163                                        dspin_rsp_width>(
164                     "wt_memc",
165                     x_width + y_width + l_width);
166
167    /////////////////////////////////////////////////////////////////////////////
168    std::ostringstream sxram;
169    sxram << "xram_" << x_id << "_" << y_id;
170    xram = new VciSimpleRam<vci_param_ext>(
171                     sxram.str().c_str(),
172                     IntTab(cluster_id),
173                     mtx,
174                     loader,
175                     xram_latency);
176
177    /////////////////////////////////////////////////////////////////////////////
178    std::ostringstream sxicu;
179    sxicu << "xicu_" << x_id << "_" << y_id;
180    xicu = new VciXicu<vci_param_int>(
181                     sxicu.str().c_str(),
182                     mtd,                               // mapping table
183                     IntTab(cluster_id, tgtid_xicu),    // TGTID_D
184                     32,                                // number of timer IRQs
185                     32,                                // number of hard IRQs
186                     32,                                // number of soft IRQs
187                     nb_procs);                         // number of output IRQs
188
189    wt_xicu = new VciDspinTargetWrapper<vci_param_int,
190                                        dspin_cmd_width,
191                                        dspin_rsp_width>(
192                     "wt_xicu",
193                     x_width + y_width + l_width);
194
195    /////////////////////////////////////////////////////////////////////////////
196    std::ostringstream smdma;
197    smdma << "mdma_" << x_id << "_" << y_id;
198    mdma = new VciMultiDma<vci_param_int>(
199                     smdma.str().c_str(),
200                     mtd,
201                     IntTab(cluster_id, nb_procs),        // SRCID
202                     IntTab(cluster_id, tgtid_mdma),      // TGTID
203                     64,                                  // burst size
204                     nb_dmas);                            // number of IRQs
205
206    wt_mdma = new VciDspinTargetWrapper<vci_param_int,
207                                        dspin_cmd_width,
208                                        dspin_rsp_width>(
209                     "wt_mdma",
210                     x_width + y_width + l_width);
211
212    wi_mdma = new VciDspinInitiatorWrapper<vci_param_int,
213                                           dspin_cmd_width,
214                                           dspin_rsp_width>(
215                     "wi_mdma",
216                     x_width + y_width + l_width);
217
218    /////////////////////////////////////////////////////////////////////////////
219    size_t nb_direct_initiators      = nb_procs + 1;
220    size_t nb_direct_targets         = 3;
221    if (io)
222    {
223        nb_direct_initiators         = nb_procs + 3;
224        nb_direct_targets            = 10;
225    }
226
227    xbar_cmd_d = new DspinLocalCrossbar<dspin_cmd_width>(
228                     "xbar_cmd_d",
229                     mtd,                          // mapping table
230                     x_id, y_id,                   // cluster coordinates
231                     x_width, y_width, l_width,
232                     nb_direct_initiators,         // number of local of sources
233                     nb_direct_targets,            // number of local dests
234                     2, 2,                         // fifo depths 
235                     true,                         // CMD
236                     true,                         // use local routing table
237                     false );                      // no broadcast
238
239    /////////////////////////////////////////////////////////////////////////////
240    xbar_rsp_d = new DspinLocalCrossbar<dspin_rsp_width>(
241                     "xbar_rsp_d",
242                     mtd,                          // mapping table
243                     x_id, y_id,                   // cluster coordinates
244                     x_width, y_width, l_width,
245                     nb_direct_targets,            // number of local sources
246                     nb_direct_initiators,         // number of local dests
247                     2, 2,                         // fifo depths 
248                     false,                        // RSP
249                     false,                        // don't use local routing table
250                     false );                      // no broadcast
251
252    /////////////////////////////////////////////////////////////////////////////
253    xbar_m2p_c = new DspinLocalCrossbar<dspin_cmd_width>(
254                     "xbar_m2p_c",
255                     mtd,                          // mapping table
256                     x_id, y_id,                   // cluster coordinates
257                     x_width, y_width, l_width,
258                     1,                            // number of local sources
259                     nb_procs,                     // number of local targets
260                     2, 2,                         // fifo depths
261                     true,                         // CMD
262                     false,                        // don't use local routing table
263                     true );                       // broadcast
264
265    /////////////////////////////////////////////////////////////////////////////
266    xbar_p2m_c = new DspinLocalCrossbar<dspin_rsp_width>(
267                     "xbar_p2m_c",
268                     mtd,                          // mapping table
269                     x_id, y_id,                   // cluster coordinates
270                     x_width, y_width, 0,          // l_width unused on p2m network
271                     nb_procs,                     // number of local sources
272                     1,                            // number of local dests
273                     2, 2,                         // fifo depths
274                     false,                        // RSP
275                     false,                        // don't use local routing table
276                     false );                      // no broadcast
277
278    /////////////////////////////////////////////////////////////////////////////
279    xbar_clack_c = new DspinLocalCrossbar<dspin_cmd_width>(
280                     "xbar_clack_c",
281                     mtd,                          // mapping table
282                     x_id, y_id,                   // cluster coordinates
283                     x_width, y_width, l_width,
284                     1,                            // number of local sources
285                     nb_procs,                     // number of local targets
286                     1, 1,                         // fifo depths
287                     true,                         // CMD
288                     false,                        // don't use local routing table
289                     false);                       // broadcast
290
291    /////////////////////////////////////////////////////////////////////////////
292    router_cmd = new VirtualDspinRouter<dspin_cmd_width>(
293                     "router_cmd",
294                     x_id,y_id,                    // coordinate in the mesh
295                     x_width, y_width,             // x & y fields width
296                     3,                            // nb virtual channels
297                     4,4);                         // input & output fifo depths
298
299    /////////////////////////////////////////////////////////////////////////////
300    router_rsp = new VirtualDspinRouter<dspin_rsp_width>(
301                     "router_rsp",
302                     x_id,y_id,                    // coordinates in mesh
303                     x_width, y_width,             // x & y fields width
304                     2,                            // nb virtual channels
305                     4,4);                         // input & output fifo depths
306
307    // IO cluster components
308    if (io)
309    {
310        /////////////////////////////////////////////
311        brom = new VciSimpleRom<vci_param_int>(
312                     "brom",
313                     IntTab(cluster_id, tgtid_brom),
314                     mtd,
315                     loader);
316
317        wt_brom = new VciDspinTargetWrapper<vci_param_int,
318                                            dspin_cmd_width,
319                                            dspin_rsp_width>(
320                     "wt_brom",
321                     x_width + y_width + l_width);
322
323        /////////////////////////////////////////////
324        fbuf = new VciFrameBuffer<vci_param_int>(
325                     "fbuf",
326                     IntTab(cluster_id, tgtid_fbuf),
327                     mtd,
328                     xfb, yfb);
329
330        wt_fbuf = new VciDspinTargetWrapper<vci_param_int,
331                                            dspin_cmd_width,
332                                            dspin_rsp_width>(
333                     "wt_fbuf",
334                     x_width + y_width + l_width);
335
336        /////////////////////////////////////////////
337        bdev = new VciBlockDeviceTsar<vci_param_int>(
338                     "bdev",
339                     mtd,
340                     IntTab(cluster_id, nb_procs + 1),
341                     IntTab(cluster_id, tgtid_bdev),
342                     disk_name,
343                     block_size,
344                     64);            // burst size
345
346        wt_bdev = new VciDspinTargetWrapper<vci_param_int,
347                                            dspin_cmd_width,
348                                            dspin_rsp_width>(
349                     "wt_bdev",
350                     x_width + y_width + l_width);
351
352        wi_bdev = new VciDspinInitiatorWrapper<vci_param_int,
353                                               dspin_cmd_width,
354                                               dspin_rsp_width>(
355                     "wi_bdev",
356                     x_width + y_width + l_width);
357
358        int mac = 0xBEEF0000;
359        mnic = new VciMultiNic<vci_param_int>(
360                     "mnic",
361                     IntTab(cluster_id, tgtid_mnic),
362                     mtd,
363                     nic_channels,
364                     mac,             // mac_4 address
365                     0xBABE,          // mac_2 address
366                     nic_rx_name,
367                     nic_tx_name);
368
369        wt_mnic = new VciDspinTargetWrapper<vci_param_int,
370                                           dspin_cmd_width,
371                                           dspin_rsp_width>(
372                    "wt_mnic",
373                    x_width + y_width + l_width);
374
375        /////////////////////////////////////////////
376        chbuf = new VciChbufDma<vci_param_int>(
377                     "chbuf_dma",
378                     mtd,
379                     IntTab(cluster_id, nb_procs + 2),
380                     IntTab(cluster_id, tgtid_chbuf),
381                     64,
382                     chbufdma_channels); 
383
384        wt_chbuf = new VciDspinTargetWrapper<vci_param_int,
385                                            dspin_cmd_width,
386                                            dspin_rsp_width>(
387                     "wt_chbuf",
388                     x_width + y_width + l_width);
389
390        wi_chbuf = new VciDspinInitiatorWrapper<vci_param_int,
391                                            dspin_cmd_width,
392                                            dspin_rsp_width>(
393                     "wi_chbuf",
394                     x_width + y_width + l_width);
395
396        /////////////////////////////////////////////
397        std::vector<std::string> vect_names;
398        for (size_t tid = 0; tid < nb_ttys; tid++)
399        {
400            std::ostringstream term_name;
401            term_name <<  "term" << tid;
402            vect_names.push_back(term_name.str().c_str());
403        }
404        mtty = new VciMultiTty<vci_param_int>(
405                     "mtty",
406                     IntTab(cluster_id, tgtid_mtty),
407                     mtd,
408                     vect_names);
409
410        wt_mtty = new VciDspinTargetWrapper<vci_param_int,
411                                            dspin_cmd_width,
412                                            dspin_rsp_width>(
413                     "wt_mtty",
414                     x_width + y_width + l_width);
415
416        simhelper = new VciSimhelper<vci_param_int>(
417                     "sim_helper",
418                     IntTab(cluster_id, tgtid_simh),
419                     mtd);
420
421        wt_simhelper = new VciDspinTargetWrapper<vci_param_int,
422                                                 dspin_cmd_width,
423                                                 dspin_rsp_width>(
424                     "wt_simhelper",
425                     x_width + y_width + l_width);
426    }
427
428    ////////////////////////////////////
429    // Connections are defined here
430    ////////////////////////////////////
431
432    //////////////////////// CMD ROUTER and RSP ROUTER
433    router_cmd->p_clk                        (this->p_clk);
434    router_cmd->p_resetn                     (this->p_resetn);
435    router_rsp->p_clk                        (this->p_clk);
436    router_rsp->p_resetn                     (this->p_resetn);
437
438    for (int i = 0; i < 4; i++)
439    {
440        for (int k = 0; k < 3; k++)
441        {
442            router_cmd->p_out[i][k]          (this->p_cmd_out[i][k]);
443            router_cmd->p_in[i][k]           (this->p_cmd_in[i][k]);
444        }
445
446        for (int k = 0; k < 2; k++)
447        {
448            router_rsp->p_out[i][k]          (this->p_rsp_out[i][k]);
449            router_rsp->p_in[i][k]           (this->p_rsp_in[i][k]);
450        }
451    }
452
453    router_cmd->p_out[4][0]                  (signal_dspin_cmd_g2l_d);
454    router_cmd->p_out[4][1]                  (signal_dspin_m2p_g2l_c);
455    router_cmd->p_out[4][2]                  (signal_dspin_clack_g2l_c);
456    router_cmd->p_in[4][0]                   (signal_dspin_cmd_l2g_d);
457    router_cmd->p_in[4][1]                   (signal_dspin_m2p_l2g_c);
458    router_cmd->p_in[4][2]                   (signal_dspin_clack_l2g_c);
459
460    router_rsp->p_out[4][0]                  (signal_dspin_rsp_g2l_d);
461    router_rsp->p_out[4][1]                  (signal_dspin_p2m_g2l_c);
462    router_rsp->p_in[4][0]                   (signal_dspin_rsp_l2g_d);
463    router_rsp->p_in[4][1]                   (signal_dspin_p2m_l2g_c);
464
465
466    std::cout << "  - CMD & RSP routers connected" << std::endl;
467
468    ///////////////////// CMD DSPIN  local crossbar direct
469    xbar_cmd_d->p_clk                            (this->p_clk);
470    xbar_cmd_d->p_resetn                         (this->p_resetn);
471    xbar_cmd_d->p_global_out                     (signal_dspin_cmd_l2g_d);
472    xbar_cmd_d->p_global_in                      (signal_dspin_cmd_g2l_d);
473
474    xbar_cmd_d->p_local_out[tgtid_memc]          (signal_dspin_cmd_memc_t);
475    xbar_cmd_d->p_local_out[tgtid_xicu]          (signal_dspin_cmd_xicu_t);
476    xbar_cmd_d->p_local_out[tgtid_mdma]          (signal_dspin_cmd_mdma_t);
477
478    xbar_cmd_d->p_local_in[nb_procs]             (signal_dspin_cmd_mdma_i);
479
480    for (size_t p = 0; p < nb_procs; p++)
481        xbar_cmd_d->p_local_in[p]                (signal_dspin_cmd_proc_i[p]);
482
483    if (io)
484    {
485        xbar_cmd_d->p_local_out[tgtid_mtty]      (signal_dspin_cmd_mtty_t);
486        xbar_cmd_d->p_local_out[tgtid_brom]      (signal_dspin_cmd_brom_t);
487        xbar_cmd_d->p_local_out[tgtid_bdev]      (signal_dspin_cmd_bdev_t);
488        xbar_cmd_d->p_local_out[tgtid_fbuf]      (signal_dspin_cmd_fbuf_t);
489        xbar_cmd_d->p_local_out[tgtid_mnic]      (signal_dspin_cmd_mnic_t);
490        xbar_cmd_d->p_local_out[tgtid_chbuf]     (signal_dspin_cmd_chbuf_t);
491        xbar_cmd_d->p_local_out[tgtid_simh]      (signal_dspin_cmd_simh_t);
492
493        xbar_cmd_d->p_local_in[nb_procs + 1]     (signal_dspin_cmd_bdev_i);
494        xbar_cmd_d->p_local_in[nb_procs + 2]     (signal_dspin_cmd_chbuf_i);
495    }
496
497    std::cout << "  - Command Direct crossbar connected" << std::endl;
498
499    //////////////////////// RSP DSPIN  local crossbar direct
500    xbar_rsp_d->p_clk                            (this->p_clk);
501    xbar_rsp_d->p_resetn                         (this->p_resetn);
502    xbar_rsp_d->p_global_out                     (signal_dspin_rsp_l2g_d);
503    xbar_rsp_d->p_global_in                      (signal_dspin_rsp_g2l_d);
504
505    xbar_rsp_d->p_local_in[tgtid_memc]           (signal_dspin_rsp_memc_t);
506    xbar_rsp_d->p_local_in[tgtid_xicu]           (signal_dspin_rsp_xicu_t);
507    xbar_rsp_d->p_local_in[tgtid_mdma]           (signal_dspin_rsp_mdma_t);
508
509    xbar_rsp_d->p_local_out[nb_procs]            (signal_dspin_rsp_mdma_i);
510
511    for (size_t p = 0; p < nb_procs; p++)
512        xbar_rsp_d->p_local_out[p]               (signal_dspin_rsp_proc_i[p]);
513
514    if (io)
515    {
516        xbar_rsp_d->p_local_in[tgtid_mtty]       (signal_dspin_rsp_mtty_t);
517        xbar_rsp_d->p_local_in[tgtid_brom]       (signal_dspin_rsp_brom_t);
518        xbar_rsp_d->p_local_in[tgtid_bdev]       (signal_dspin_rsp_bdev_t);
519        xbar_rsp_d->p_local_in[tgtid_fbuf]       (signal_dspin_rsp_fbuf_t);
520        xbar_rsp_d->p_local_in[tgtid_mnic]       (signal_dspin_rsp_mnic_t);
521        xbar_rsp_d->p_local_in[tgtid_chbuf]      (signal_dspin_rsp_chbuf_t);
522        xbar_rsp_d->p_local_in[tgtid_simh]       (signal_dspin_rsp_simh_t);
523
524        xbar_rsp_d->p_local_out[nb_procs + 1]    (signal_dspin_rsp_bdev_i);
525        xbar_rsp_d->p_local_out[nb_procs + 2]    (signal_dspin_rsp_chbuf_i);
526    }
527
528    std::cout << "  - Response Direct crossbar connected" << std::endl;
529
530    ////////////////////// M2P DSPIN local crossbar coherence
531    xbar_m2p_c->p_clk                            (this->p_clk);
532    xbar_m2p_c->p_resetn                         (this->p_resetn);
533    xbar_m2p_c->p_global_out                     (signal_dspin_m2p_l2g_c);
534    xbar_m2p_c->p_global_in                      (signal_dspin_m2p_g2l_c);
535    xbar_m2p_c->p_local_in[0]                    (signal_dspin_m2p_memc);
536    for (size_t p = 0; p < nb_procs; p++)
537        xbar_m2p_c->p_local_out[p]               (signal_dspin_m2p_proc[p]);
538
539    std::cout << "  - M2P Coherence crossbar connected" << std::endl;
540
541    ////////////////////// CLACK DSPIN local crossbar coherence
542    xbar_clack_c->p_clk                          (this->p_clk);
543    xbar_clack_c->p_resetn                       (this->p_resetn);
544    xbar_clack_c->p_global_out                   (signal_dspin_clack_l2g_c);
545    xbar_clack_c->p_global_in                    (signal_dspin_clack_g2l_c);
546    xbar_clack_c->p_local_in[0]                  (signal_dspin_clack_memc);
547    for (size_t p = 0; p < nb_procs; p++)
548        xbar_clack_c->p_local_out[p]             (signal_dspin_clack_proc[p]);
549
550    std::cout << "  - Clack Coherence crossbar connected" << std::endl;
551
552    ////////////////////////// P2M DSPIN local crossbar coherence
553    xbar_p2m_c->p_clk                            (this->p_clk);
554    xbar_p2m_c->p_resetn                         (this->p_resetn);
555    xbar_p2m_c->p_global_out                     (signal_dspin_p2m_l2g_c);
556    xbar_p2m_c->p_global_in                      (signal_dspin_p2m_g2l_c);
557    xbar_p2m_c->p_local_out[0]                   (signal_dspin_p2m_memc);
558    for (size_t p = 0; p < nb_procs; p++)
559        xbar_p2m_c->p_local_in[p]                (signal_dspin_p2m_proc[p]);
560
561    std::cout << "  - P2M Coherence crossbar connected" << std::endl;
562
563
564    //////////////////////////////////// Processors
565    for (size_t p = 0; p < nb_procs; p++)
566    {
567        proc[p]->p_clk                      (this->p_clk);
568        proc[p]->p_resetn                   (this->p_resetn);
569        proc[p]->p_vci                      (signal_vci_ini_proc[p]);
570        proc[p]->p_dspin_m2p                (signal_dspin_m2p_proc[p]);
571        proc[p]->p_dspin_p2m                (signal_dspin_p2m_proc[p]);
572        proc[p]->p_dspin_clack              (signal_dspin_clack_proc[p]);
573        proc[p]->p_irq[0]                   (signal_proc_it[p]);
574        for ( size_t j = 1 ; j < 6 ; j++)
575        {
576            proc[p]->p_irq[j]               (signal_false);
577        }
578
579        wi_proc[p]->p_clk                   (this->p_clk);
580        wi_proc[p]->p_resetn                (this->p_resetn);
581        wi_proc[p]->p_dspin_cmd             (signal_dspin_cmd_proc_i[p]);
582        wi_proc[p]->p_dspin_rsp             (signal_dspin_rsp_proc_i[p]);
583        wi_proc[p]->p_vci                   (signal_vci_ini_proc[p]);
584    }
585
586    std::cout << "  - Processors connected" << std::endl;
587
588    ///////////////////////////////////// XICU
589    xicu->p_clk                        (this->p_clk);
590    xicu->p_resetn                     (this->p_resetn);
591    xicu->p_vci                        (signal_vci_tgt_xicu);
592    for (size_t p = 0; p < nb_procs; p++)
593    {
594        xicu->p_irq[p]                 (signal_proc_it[p]);
595    }
596
597    for (size_t i = 0; i < 32; i++)
598    {
599        if (io) // I/O cluster
600        {
601            if      (i < 8)                  xicu->p_hwi[i] (signal_false);
602            else if (i < (8 + nb_dmas))      xicu->p_hwi[i] (signal_irq_mdma[i - 8]);
603            else if (i < 16)                 xicu->p_hwi[i] (signal_false);
604            else if (i < (16 + nb_ttys))     xicu->p_hwi[i] (signal_irq_mtty[i - 16]);
605            else if (i < 30)                 xicu->p_hwi[i] (signal_false);
606            else if (i < 31)                 xicu->p_hwi[i] (signal_irq_memc);
607            else                             xicu->p_hwi[i] (signal_irq_bdev);
608        }
609        else      // other clusters
610        {
611            if      (i < 8)                  xicu->p_hwi[i] (signal_false);
612            else if (i < (8 + nb_dmas))      xicu->p_hwi[i] (signal_irq_mdma[i - 8]);
613            else if (i < 30)                 xicu->p_hwi[i] (signal_false);
614            else if (i < 31)                 xicu->p_hwi[i] (signal_irq_memc);
615            else                             xicu->p_hwi[i] (signal_false);
616        }
617    }
618
619    // wrapper XICU
620    wt_xicu->p_clk                     (this->p_clk);
621    wt_xicu->p_resetn                  (this->p_resetn);
622    wt_xicu->p_dspin_cmd               (signal_dspin_cmd_xicu_t);
623    wt_xicu->p_dspin_rsp               (signal_dspin_rsp_xicu_t);
624    wt_xicu->p_vci                     (signal_vci_tgt_xicu);
625
626    std::cout << "  - XICU connected" << std::endl;
627
628    //////////////////////////////////////////////// MEMC
629    memc->p_clk                        (this->p_clk);
630    memc->p_resetn                     (this->p_resetn);
631    memc->p_irq                        (signal_irq_memc);
632    memc->p_vci_ixr                    (signal_vci_xram);
633    memc->p_vci_tgt                    (signal_vci_tgt_memc);
634    memc->p_dspin_p2m                  (signal_dspin_p2m_memc);
635    memc->p_dspin_m2p                  (signal_dspin_m2p_memc);
636    memc->p_dspin_clack                (signal_dspin_clack_memc);
637
638    // wrapper MEMC
639    wt_memc->p_clk                     (this->p_clk);
640    wt_memc->p_resetn                  (this->p_resetn);
641    wt_memc->p_dspin_cmd               (signal_dspin_cmd_memc_t);
642    wt_memc->p_dspin_rsp               (signal_dspin_rsp_memc_t);
643    wt_memc->p_vci                     (signal_vci_tgt_memc);
644
645    std::cout << "  - MEMC connected" << std::endl;
646
647    /////////////////////////////////////////////// XRAM
648    xram->p_clk                        (this->p_clk);
649    xram->p_resetn                     (this->p_resetn);
650    xram->p_vci                        (signal_vci_xram);
651
652    std::cout << "  - XRAM connected" << std::endl;
653
654    ////////////////////////////////////////////// MDMA
655    mdma->p_clk                        (this->p_clk);
656    mdma->p_resetn                     (this->p_resetn);
657    mdma->p_vci_target                 (signal_vci_tgt_mdma);
658    mdma->p_vci_initiator              (signal_vci_ini_mdma);
659    for (size_t i = 0; i < nb_dmas; i++)
660        mdma->p_irq[i]                 (signal_irq_mdma[i]);
661
662    // wrapper tgt MDMA
663    wt_mdma->p_clk                     (this->p_clk);
664    wt_mdma->p_resetn                  (this->p_resetn);
665    wt_mdma->p_dspin_cmd               (signal_dspin_cmd_mdma_t);
666    wt_mdma->p_dspin_rsp               (signal_dspin_rsp_mdma_t);
667    wt_mdma->p_vci                     (signal_vci_tgt_mdma);
668
669    // wrapper ini MDMA
670    wi_mdma->p_clk                     (this->p_clk);
671    wi_mdma->p_resetn                  (this->p_resetn);
672    wi_mdma->p_dspin_cmd               (signal_dspin_cmd_mdma_i);
673    wi_mdma->p_dspin_rsp               (signal_dspin_rsp_mdma_i);
674    wi_mdma->p_vci                     (signal_vci_ini_mdma);
675
676    std::cout << "  - MDMA connected" << std::endl;
677
678    /////////////////////////////// Components in I/O cluster
679
680    if (io)
681    {
682        // BDEV
683        bdev->p_clk                    (this->p_clk);
684        bdev->p_resetn                 (this->p_resetn);
685        bdev->p_irq                    (signal_irq_bdev);
686        bdev->p_vci_target             (signal_vci_tgt_bdev);
687        bdev->p_vci_initiator          (signal_vci_ini_bdev);
688
689        // wrapper tgt BDEV
690        wt_bdev->p_clk                 (this->p_clk);
691        wt_bdev->p_resetn              (this->p_resetn);
692        wt_bdev->p_dspin_cmd           (signal_dspin_cmd_bdev_t);
693        wt_bdev->p_dspin_rsp           (signal_dspin_rsp_bdev_t);
694        wt_bdev->p_vci                 (signal_vci_tgt_bdev);
695
696        // wrapper ini BDEV
697        wi_bdev->p_clk                 (this->p_clk);
698        wi_bdev->p_resetn              (this->p_resetn);
699        wi_bdev->p_dspin_cmd           (signal_dspin_cmd_bdev_i);
700        wi_bdev->p_dspin_rsp           (signal_dspin_rsp_bdev_i);
701        wi_bdev->p_vci                 (signal_vci_ini_bdev);
702
703        std::cout << "  - BDEV connected" << std::endl;
704
705        // FBUF
706        fbuf->p_clk                    (this->p_clk);
707        fbuf->p_resetn                 (this->p_resetn);
708        fbuf->p_vci                    (signal_vci_tgt_fbuf);
709
710        // wrapper tgt FBUF
711        wt_fbuf->p_clk                 (this->p_clk);
712        wt_fbuf->p_resetn              (this->p_resetn);
713        wt_fbuf->p_dspin_cmd           (signal_dspin_cmd_fbuf_t);
714        wt_fbuf->p_dspin_rsp           (signal_dspin_rsp_fbuf_t);
715        wt_fbuf->p_vci                 (signal_vci_tgt_fbuf);
716
717        std::cout << "  - FBUF connected" << std::endl;
718
719        // MNIC
720        mnic->p_clk                    (this->p_clk);
721        mnic->p_resetn                 (this->p_resetn);
722        mnic->p_vci                    (signal_vci_tgt_mnic);
723        for (size_t i = 0; i < nic_channels; i++)
724        {
725            mnic->p_rx_irq[i]          (signal_irq_mnic_rx[i]);
726            mnic->p_tx_irq[i]          (signal_irq_mnic_tx[i]);
727        }
728
729        // wrapper tgt MNIC
730        wt_mnic->p_clk                 (this->p_clk);
731        wt_mnic->p_resetn              (this->p_resetn);
732        wt_mnic->p_dspin_cmd           (signal_dspin_cmd_mnic_t);
733        wt_mnic->p_dspin_rsp           (signal_dspin_rsp_mnic_t);
734        wt_mnic->p_vci                 (signal_vci_tgt_mnic);
735
736        std::cout << "  - MNIC connected" << std::endl;
737
738        // CHBUF
739        chbuf->p_clk                    (this->p_clk);
740        chbuf->p_resetn                 (this->p_resetn);
741        chbuf->p_vci_target             (signal_vci_tgt_chbuf);
742        chbuf->p_vci_initiator          (signal_vci_ini_chbuf);
743        for (size_t i = 0; i < chbufdma_channels; i++)
744        {
745            chbuf->p_irq[i]          (signal_irq_chbuf[i]);
746        }
747
748        // wrapper tgt CHBUF
749        wt_chbuf->p_clk                 (this->p_clk);
750        wt_chbuf->p_resetn              (this->p_resetn);
751        wt_chbuf->p_dspin_cmd           (signal_dspin_cmd_chbuf_t);
752        wt_chbuf->p_dspin_rsp           (signal_dspin_rsp_chbuf_t);
753        wt_chbuf->p_vci                 (signal_vci_tgt_chbuf);
754
755        // wrapper ini CHBUF
756        wi_chbuf->p_clk                 (this->p_clk);
757        wi_chbuf->p_resetn              (this->p_resetn);
758        wi_chbuf->p_dspin_cmd           (signal_dspin_cmd_chbuf_i);
759        wi_chbuf->p_dspin_rsp           (signal_dspin_rsp_chbuf_i);
760        wi_chbuf->p_vci                 (signal_vci_ini_chbuf);
761
762        std::cout << "  - CHBUF connected" << std::endl;
763
764        // BROM
765        brom->p_clk                    (this->p_clk);
766        brom->p_resetn                 (this->p_resetn);
767        brom->p_vci                    (signal_vci_tgt_brom);
768
769        // wrapper tgt BROM
770        wt_brom->p_clk                 (this->p_clk);
771        wt_brom->p_resetn              (this->p_resetn);
772        wt_brom->p_dspin_cmd           (signal_dspin_cmd_brom_t);
773        wt_brom->p_dspin_rsp           (signal_dspin_rsp_brom_t);
774        wt_brom->p_vci                 (signal_vci_tgt_brom);
775
776        std::cout << "  - BROM connected" << std::endl;
777
778        // MTTY
779        mtty->p_clk                    (this->p_clk);
780        mtty->p_resetn                 (this->p_resetn);
781        mtty->p_vci                    (signal_vci_tgt_mtty);
782        for (size_t i = 0; i < nb_ttys; i++)
783        {
784            mtty->p_irq[i]             (signal_irq_mtty[i]);
785        }
786
787        // wrapper tgt MTTY
788        wt_mtty->p_clk                 (this->p_clk);
789        wt_mtty->p_resetn              (this->p_resetn);
790        wt_mtty->p_dspin_cmd           (signal_dspin_cmd_mtty_t);
791        wt_mtty->p_dspin_rsp           (signal_dspin_rsp_mtty_t);
792        wt_mtty->p_vci                 (signal_vci_tgt_mtty);
793
794
795        // Sim Helper
796        simhelper->p_clk               (this->p_clk);
797        simhelper->p_resetn            (this->p_resetn);
798        simhelper->p_vci               (signal_vci_tgt_simh);
799       
800        // wrapper tgt Sim Helper
801        wt_simhelper->p_clk            (this->p_clk);
802        wt_simhelper->p_resetn         (this->p_resetn);
803        wt_simhelper->p_dspin_cmd      (signal_dspin_cmd_simh_t);
804        wt_simhelper->p_dspin_rsp      (signal_dspin_rsp_simh_t);
805        wt_simhelper->p_vci            (signal_vci_tgt_simh);
806
807        std::cout << "  - MTTY connected" << std::endl;
808   }
809} // end constructor
810
811
812
813template<size_t dspin_cmd_width,
814         size_t dspin_rsp_width,
815         typename vci_param_int,
816         typename vci_param_ext> TsarXbarCluster<dspin_cmd_width,
817                                                 dspin_rsp_width,
818                                                 vci_param_int,
819                                                 vci_param_ext>::~TsarXbarCluster() {
820
821    dealloc_elems<DspinInput<dspin_cmd_width> > (p_cmd_in, 4, 3);
822    dealloc_elems<DspinOutput<dspin_cmd_width> >(p_cmd_out, 4, 3);
823    dealloc_elems<DspinInput<dspin_rsp_width> > (p_rsp_in, 4, 2);
824    dealloc_elems<DspinOutput<dspin_rsp_width> >(p_rsp_out, 4, 2);
825
826    for (size_t p = 0; p < n_procs; p++)
827    {
828        delete proc[p];
829        delete wi_proc[p];
830    }
831
832    delete memc;
833    delete wt_memc;
834    delete xram;
835    delete xicu;
836    delete wt_xicu;
837    delete mdma;
838    delete wt_mdma;
839    delete wi_mdma;
840    delete xbar_cmd_d;
841    delete xbar_rsp_d;
842    delete xbar_m2p_c;
843    delete xbar_p2m_c;
844    delete xbar_clack_c;
845    delete router_cmd;
846    delete router_rsp;
847    if (brom != NULL)
848    {
849        delete brom;
850        delete wt_brom;
851        delete fbuf;
852        delete wt_fbuf;
853        delete bdev;
854        delete wt_bdev;
855        delete wi_bdev;
856        delete mnic;
857        delete wt_mnic;
858        delete chbuf;
859        delete wt_chbuf;
860        delete wi_chbuf;
861        delete mtty;
862        delete wt_mtty;
863        delete simhelper;
864        delete wt_simhelper;
865    }
866}
867
868
869}}
870
871// Local Variables:
872// tab-width: 4
873// c-basic-offset: 4
874// c-file-offsets:((innamespace . 0)(inline-open . 0))
875// indent-tabs-mode: nil
876// End:
877
878// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
879
880
881
Note: See TracBrowser for help on using the repository browser.