source: trunk/platforms/tsar_generic_iob/tsar_iob_cluster/caba/source/src/tsar_iob_cluster.cpp @ 533

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

Modification in tsar_generic_iob platform:

  • Fixing compilation error concerning the unexisting bind function in the SystemC sc_in class
File size: 39.9 KB
Line 
1//////////////////////////////////////////////////////////////////////////////
2// File: tsar_iob_cluster.cpp
3// Author: Alain Greiner
4// Copyright: UPMC/LIP6
5// Date : april 2013
6// This program is released under the GNU public license
7//////////////////////////////////////////////////////////////////////////////
8// Cluster(0,0) & Cluster(xmax-1,ymax-1) contains the IOB0 & IOB1 components.
9// These two clusters contain 6 extra components:
10// - 1 vci_io_bridge (connected to the 3 networks.
11// - 3 vci_dspin_wrapper for the IOB.
12// - 2 dspin_local_crossbar for commands and responses.
13//////////////////////////////////////////////////////////////////////////////
14
15#include "../include/tsar_iob_cluster.h"
16
17namespace soclib { namespace caba  {
18
19//////////////////////////////////////////////////////////////////////////
20//                 Constructor
21//////////////////////////////////////////////////////////////////////////
22template<typename vci_param_int, 
23         typename vci_param_ext,
24         size_t   dspin_int_cmd_width, 
25         size_t   dspin_int_rsp_width,
26         size_t   dspin_ram_cmd_width, 
27         size_t   dspin_ram_rsp_width>
28TsarIobCluster<vci_param_int, 
29               vci_param_ext,
30               dspin_int_cmd_width, 
31               dspin_int_rsp_width,
32               dspin_ram_cmd_width, 
33               dspin_ram_rsp_width>::TsarIobCluster(
34//////////////////////////////////////////////////////////////////////////
35                    sc_module_name                     insname,
36                    size_t                             nb_procs,
37                    size_t                             nb_dmas,
38                    size_t                             x_id,
39                    size_t                             y_id,
40                    size_t                             xmax,
41                    size_t                             ymax,
42
43                    const soclib::common::MappingTable &mt_int,
44                    const soclib::common::MappingTable &mt_ram, 
45                    const soclib::common::MappingTable &mt_iox, 
46
47                    size_t                             x_width,
48                    size_t                             y_width,
49                    size_t                             l_width,
50
51                    size_t                             memc_int_tgtid,
52                    size_t                             xicu_int_tgtid,
53                    size_t                             mdma_int_tgtid,
54                    size_t                             iobx_int_tgtid,
55
56                    size_t                             proc_int_srcid,
57                    size_t                             mdma_int_srcid,
58                    size_t                             iobx_int_srcid,
59
60                    size_t                             xram_ram_tgtid,
61
62                    size_t                             memc_ram_srcid,
63                    size_t                             iobx_ram_srcid,
64
65                    size_t                             memc_ways,
66                    size_t                             memc_sets,
67                    size_t                             l1_i_ways,
68                    size_t                             l1_i_sets,
69                    size_t                             l1_d_ways,
70                    size_t                             l1_d_sets,
71                    size_t                             xram_latency,
72
73                    const Loader                      &loader,
74
75                    uint32_t                           frozen_cycles,
76                    uint32_t                           debug_start_cycle,
77                    bool                               memc_debug_ok,
78                    bool                               proc_debug_ok,
79                    bool                               iob_debug_ok )
80    : soclib::caba::BaseModule(insname),
81      p_clk("clk"),
82      p_resetn("resetn")
83{
84    assert( (x_id < xmax) and (y_id < ymax) and "Illegal cluster coordinates");
85
86    size_t cluster_id = x_id * ymax + y_id;
87    size_t cluster_iob0 = 0;
88    size_t cluster_iob1 = xmax*ymax-1;
89
90    // Vectors of DSPIN ports for inter-cluster communications
91    p_dspin_int_cmd_in  = alloc_elems<DspinInput<dspin_int_cmd_width> >("p_int_cmd_in", 4, 3);
92    p_dspin_int_cmd_out = alloc_elems<DspinOutput<dspin_int_cmd_width> >("p_int_cmd_out", 4, 3);
93    p_dspin_int_rsp_in  = alloc_elems<DspinInput<dspin_int_rsp_width> >("p_int_rsp_in", 4, 2);
94    p_dspin_int_rsp_out = alloc_elems<DspinOutput<dspin_int_rsp_width> >("p_int_rsp_out", 4, 2);
95
96    p_dspin_ram_cmd_in  = alloc_elems<DspinInput<dspin_ram_cmd_width> >("p_ext_cmd_in", 4);
97    p_dspin_ram_cmd_out = alloc_elems<DspinOutput<dspin_ram_cmd_width> >("p_ext_cmd_out", 4);
98    p_dspin_ram_rsp_in  = alloc_elems<DspinInput<dspin_ram_rsp_width> >("p_ext_rsp_in", 4);
99    p_dspin_ram_rsp_out = alloc_elems<DspinOutput<dspin_ram_rsp_width> >("p_ext_rsp_out", 4);
100
101    // VCI ports to IOB0 and IOB1 in cluster_iob0 and cluster_iob1
102    if ( (cluster_id == cluster_iob0) or (cluster_id == cluster_iob1) )
103    {
104        p_vci_iox_ini = new soclib::caba::VciInitiator<vci_param_ext>;
105        p_vci_iox_tgt = new soclib::caba::VciTarget<vci_param_ext>; 
106    }
107
108    // IRQ ports in cluster_iob0 only
109    if ( cluster_id == cluster_iob0 )
110    {
111        for ( size_t n=0 ; n<32 ; n++ ) p_irq[n] = new sc_in<bool>;
112    }
113
114    /////////////////////////////////////////////////////////////////////////////
115    //    Hardware components
116    /////////////////////////////////////////////////////////////////////////////
117
118    ////////////  PROCS
119    for (size_t p = 0; p < nb_procs; p++)
120    { 
121        std::ostringstream s_proc;
122        s_proc << "proc_" << x_id << "_" << y_id << "_" << p;
123        proc[p] = new VciCcVCacheWrapper<vci_param_int,
124                                         dspin_int_cmd_width,
125                                         dspin_int_rsp_width,
126                                         GdbServer<Mips32ElIss> >(
127                      s_proc.str().c_str(),
128                      cluster_id*nb_procs + p,        // GLOBAL PROC_ID
129                      mt_int,                         // Mapping Table INT network
130                      IntTab(cluster_id,p),           // SRCID
131                      (cluster_id << l_width) + p,    // CC_GLOBAL_ID
132                      8,                              // ITLB ways
133                      8,                              // ITLB sets
134                      8,                              // DTLB ways
135                      8,                              // DTLB sets
136                      l1_i_ways,l1_i_sets,16,         // ICACHE size
137                      l1_d_ways,l1_d_sets,16,         // DCACHE size
138                      4,                              // WBUF nlines
139                      4,                              // WBUF nwords
140                      x_width,
141                      y_width,
142                      frozen_cycles,                  // max frozen cycles
143                      debug_start_cycle,
144                      proc_debug_ok);
145
146        std::ostringstream s_wi_proc;
147        s_wi_proc << "proc_wi_" << x_id << "_" << y_id << "_" << p;
148        proc_wi[p] = new VciDspinInitiatorWrapper<vci_param_int,
149                                                      dspin_int_cmd_width,
150                                                      dspin_int_rsp_width>(
151                     s_wi_proc.str().c_str(),
152                     x_width + y_width + l_width);
153    }
154
155    ///////////  MEMC   
156    std::ostringstream s_memc;
157    s_memc << "memc_" << x_id << "_" << y_id;
158    memc = new VciMemCache<vci_param_int,
159                           vci_param_ext,
160                           dspin_int_rsp_width,
161                           dspin_int_cmd_width>(
162                     s_memc.str().c_str(),
163                     mt_int,                             // Mapping Table INT network
164                     mt_ram,                             // Mapping Table RAM network
165                     IntTab(cluster_id, memc_ram_srcid), // SRCID RAM network
166                     IntTab(cluster_id, memc_int_tgtid), // TGTID INT network
167                     (cluster_id << l_width) + nb_procs, // CC_GLOBAL_ID
168                     x_width,                            // Number of x bits in platform
169                     y_width,                            // Number of y bits in platform
170                     memc_ways, memc_sets, 16,           // CACHE SIZE
171                     3,                                  // MAX NUMBER OF COPIES
172                     4096,                               // HEAP SIZE
173                     8,                                  // TRANSACTION TABLE DEPTH
174                     8,                                  // UPDATE TABLE DEPTH
175                     8,                                  // INVALIDATE TABLE DEPTH
176                     debug_start_cycle,
177                     memc_debug_ok );
178
179    std::ostringstream s_wt_memc;
180    s_wt_memc << "memc_wt_" << x_id << "_" << y_id;
181    memc_int_wt = new VciDspinTargetWrapper<vci_param_int,
182                                            dspin_int_cmd_width,
183                                            dspin_int_rsp_width>(
184                     s_wt_memc.str().c_str(),
185                     x_width + y_width + l_width);
186
187    std::ostringstream s_wi_memc;
188    s_wi_memc << "memc_wi_" << x_id << "_" << y_id;
189    memc_ram_wi = new VciDspinInitiatorWrapper<vci_param_ext,
190                                               dspin_ram_cmd_width,
191                                               dspin_ram_rsp_width>(
192                     s_wi_memc.str().c_str(),
193                     x_width + y_width + l_width);
194
195    ///////////   XICU
196    std::ostringstream s_xicu;
197    s_xicu << "xicu_" << x_id << "_" << y_id;
198    xicu = new VciXicu<vci_param_int>(
199                     s_xicu.str().c_str(),
200                     mt_int,                            // mapping table INT network
201                     IntTab(cluster_id,xicu_int_tgtid), // TGTID direct space
202                     nb_procs,                          // number of timer IRQs
203                     32,                                // number of hard IRQs
204                     32,                                // number of soft IRQs
205                     nb_procs);                         // number of output IRQs
206
207    std::ostringstream s_wt_xicu;
208    s_wt_xicu << "xicu_wt_" << x_id << "_" << y_id;
209    xicu_int_wt = new VciDspinTargetWrapper<vci_param_int,
210                                        dspin_int_cmd_width,
211                                        dspin_int_rsp_width>(
212                     s_wt_xicu.str().c_str(),
213                     x_width + y_width + l_width);
214
215    ////////////  MDMA
216    std::ostringstream s_mdma;
217    s_mdma << "mdma_" << x_id << "_" << y_id;
218    mdma = new VciMultiDma<vci_param_int>(
219                     s_mdma.str().c_str(),
220                     mt_int,
221                     IntTab(cluster_id, nb_procs),        // SRCID
222                     IntTab(cluster_id, mdma_int_tgtid),  // TGTID
223                     64,                                  // burst size
224                     nb_dmas);                            // number of IRQs
225
226    std::ostringstream s_wt_mdma;
227    s_wt_mdma << "mdma_wt_" << x_id << "_" << y_id;
228    mdma_int_wt = new VciDspinTargetWrapper<vci_param_int,
229                                            dspin_int_cmd_width,
230                                            dspin_int_rsp_width>(
231                     s_wt_mdma.str().c_str(),
232                     x_width + y_width + l_width);
233
234    std::ostringstream s_wi_mdma;
235    s_wi_mdma << "mdma_wi_" << x_id << "_" << y_id;
236    mdma_int_wi = new VciDspinInitiatorWrapper<vci_param_int,
237                                               dspin_int_cmd_width,
238                                               dspin_int_rsp_width>(
239                     s_wi_mdma.str().c_str(),
240                     x_width + y_width + l_width);
241
242    ///////////  Direct LOCAL_XBAR(S)
243    size_t nb_direct_initiators      = nb_procs + 1;
244    size_t nb_direct_targets         = 3;
245    if ( (cluster_id == cluster_iob0) or (cluster_id == cluster_iob1) )
246    {
247        nb_direct_initiators         = nb_procs + 2;
248        nb_direct_targets            = 4;
249    }
250
251    std::ostringstream s_int_xbar_cmd_d;
252    s_int_xbar_cmd_d << "int_xbar_cmd_d_" << x_id << "_" << y_id;
253    int_xbar_cmd_d = new DspinLocalCrossbar<dspin_int_cmd_width>(
254                     s_int_xbar_cmd_d.str().c_str(),
255                     mt_int,                       // mapping table
256                     x_id, y_id,                   // cluster coordinates
257                     x_width, y_width, l_width,
258                     nb_direct_initiators,         // number of local of sources
259                     nb_direct_targets,            // number of local dests
260                     2, 2,                         // fifo depths 
261                     true,                         // CMD crossbar
262                     true,                         // use routing table
263                     false );                      // no broacast
264
265    std::ostringstream s_int_xbar_rsp_d;
266    s_int_xbar_rsp_d << "int_xbar_rsp_d_" << x_id << "_" << y_id;
267    int_xbar_rsp_d = new DspinLocalCrossbar<dspin_int_rsp_width>(
268                     s_int_xbar_rsp_d.str().c_str(),
269                     mt_int,                       // mapping table
270                     x_id, y_id,                   // cluster coordinates
271                     x_width, y_width, l_width,
272                     nb_direct_targets,            // number of local sources     
273                     nb_direct_initiators,         // number of local dests
274                     2, 2,                         // fifo depths
275                     false,                        // RSP crossbar 
276                     false,                        // don't use routing table
277                     false );                      // no broacast
278
279    ////////////  Coherence LOCAL_XBAR(S)
280    std::ostringstream s_int_xbar_m2p_c;
281    s_int_xbar_m2p_c << "int_xbar_m2p_c_" << x_id << "_" << y_id;
282    int_xbar_m2p_c = new DspinLocalCrossbar<dspin_int_cmd_width>(
283                     s_int_xbar_m2p_c.str().c_str(),
284                     mt_int,                       // mapping table
285                     x_id, y_id,                   // cluster coordinates
286                     x_width, y_width, l_width,    // several dests
287                     1,                            // number of local sources
288                     nb_procs,                     // number of local dests
289                     2, 2,                         // fifo depths 
290                     true,                         // pseudo CMD
291                     false,                        // no routing table
292                     true );                       // broacast
293
294    std::ostringstream s_int_xbar_p2m_c;
295    s_int_xbar_p2m_c << "int_xbar_p2m_c_" << x_id << "_" << y_id;
296    int_xbar_p2m_c = new DspinLocalCrossbar<dspin_int_rsp_width>(
297                     s_int_xbar_p2m_c.str().c_str(),
298                     mt_int,                       // mapping table
299                     x_id, y_id,                   // cluster coordinates
300                     x_width, y_width, 0,          // only one dest
301                     nb_procs,                     // number of local sources
302                     1,                            // number of local dests
303                     2, 2,                         // fifo depths 
304                     false,                        // pseudo RSP
305                     false,                        // no routing table
306                     false );                      // no broacast
307
308    std::ostringstream s_int_xbar_clack_c;
309    s_int_xbar_clack_c << "int_xbar_clack_c_" << x_id << "_" << y_id;
310    int_xbar_clack_c = new DspinLocalCrossbar<dspin_int_cmd_width>(
311                     s_int_xbar_clack_c.str().c_str(),
312                     mt_int,                       // mapping table
313                     x_id, y_id,                   // cluster coordinates
314                     x_width, y_width, l_width,
315                     1,                            // number of local sources
316                     nb_procs,                     // number of local targets
317                     1, 1,                         // fifo depths
318                     true,                         // CMD
319                     false,                        // don't use local routing table
320                     false);                       // broadcast
321
322    //////////////  INT ROUTER(S)
323    std::ostringstream s_int_router_cmd;
324    s_int_router_cmd << "router_cmd_" << x_id << "_" << y_id;
325    int_router_cmd = new VirtualDspinRouter<dspin_int_cmd_width>(
326                     s_int_router_cmd.str().c_str(),
327                     x_id,y_id,                    // coordinate in the mesh
328                     x_width, y_width,             // x & y fields width
329                     3,                            // nb virtual channels
330                     4,4);                         // input & output fifo depths
331
332    std::ostringstream s_int_router_rsp;
333    s_int_router_rsp << "router_rsp_" << x_id << "_" << y_id;
334    int_router_rsp = new VirtualDspinRouter<dspin_int_rsp_width>(
335                     s_int_router_rsp.str().c_str(),
336                     x_id,y_id,                    // coordinates in mesh
337                     x_width, y_width,             // x & y fields width
338                     2,                            // nb virtual channels
339                     4,4);                         // input & output fifo depths
340
341    //////////////  XRAM
342    std::ostringstream s_xram;
343    s_xram << "xram_" << x_id << "_" << y_id;
344    xram = new VciSimpleRam<vci_param_ext>(
345                     s_xram.str().c_str(),
346                     IntTab(cluster_id, xram_ram_tgtid ),
347                     mt_ram,
348                     loader,
349                     xram_latency);
350
351    std::ostringstream s_wt_xram;
352    s_wt_xram << "xram_wt_" << x_id << "_" << y_id;
353    xram_ram_wt = new VciDspinTargetWrapper<vci_param_ext,
354                                            dspin_ram_cmd_width,
355                                            dspin_ram_rsp_width>(
356                     s_wt_xram.str().c_str(),
357                     x_width + y_width + l_width);
358
359    /////////////  RAM ROUTER(S)
360    std::ostringstream s_ram_router_cmd;
361    s_ram_router_cmd << "ram_router_cmd_" << x_id << "_" << y_id;
362    ram_router_cmd = new DspinRouter<dspin_ram_cmd_width>(
363                     s_ram_router_cmd.str().c_str(),
364                     x_id,y_id,                    // coordinate in the mesh
365                     x_width, y_width,             // x & y fields width
366                     4,4);                         // input & output fifo depths
367
368    std::ostringstream s_ram_router_rsp;
369    s_ram_router_rsp << "ram_router_rsp_" << x_id << "_" << y_id;
370    ram_router_rsp = new DspinRouter<dspin_ram_rsp_width>(
371                     s_ram_router_rsp.str().c_str(),
372                     x_id,y_id,                    // coordinates in mesh
373                     x_width, y_width,             // x & y fields width
374                     4,4);                         // input & output fifo depths
375
376    ////////////////////// I/O  CLUSTER ONLY    ///////////////////////
377    if ( (cluster_id == cluster_iob0) or (cluster_id == cluster_iob1) )
378    {
379        ///////////  IO_BRIDGE
380        size_t iox_local_id;
381        size_t global_id;
382        bool   has_irqs;
383        if ( cluster_id == cluster_iob0 ) 
384        {
385            iox_local_id = 0;
386            global_id    = cluster_iob0;
387            has_irqs     = true;
388        }
389        else
390        {
391            iox_local_id = 1;
392            global_id    = cluster_iob1;
393            has_irqs     = false;
394        }
395
396        std::ostringstream s_iob;
397        s_iob << "iob_" << x_id << "_" << y_id;   
398        iob = new VciIoBridge<vci_param_int,
399                              vci_param_ext>( 
400                     s_iob.str().c_str(),
401                     mt_ram,                               // EXT network maptab
402                     mt_int,                               // INT network maptab
403                     mt_iox,                               // IOX network maptab
404                     IntTab( global_id, iobx_int_tgtid ),  // INT TGTID
405                     IntTab( global_id, iobx_int_srcid ),  // INT SRCID
406                     IntTab( global_id, iox_local_id   ),  // IOX TGTID
407                     has_irqs, 
408                     16,                                   // cache line words
409                     8,                                    // IOTLB ways
410                     8,                                    // IOTLB sets
411                     debug_start_cycle,
412                     iob_debug_ok );
413       
414        std::ostringstream s_iob_int_wi;
415        s_iob_int_wi << "iob_int_wi_" << x_id << "_" << y_id;   
416        iob_int_wi = new VciDspinInitiatorWrapper<vci_param_int,
417                                                  dspin_int_cmd_width,
418                                                  dspin_int_rsp_width>(
419                     s_iob_int_wi.str().c_str(),
420                     x_width + y_width + l_width);
421
422        std::ostringstream s_iob_int_wt;
423        s_iob_int_wt << "iob_int_wt_" << x_id << "_" << y_id;   
424        iob_int_wt = new VciDspinTargetWrapper<vci_param_int,
425                                               dspin_int_cmd_width,
426                                               dspin_int_rsp_width>(
427                     s_iob_int_wt.str().c_str(),
428                     x_width + y_width + l_width);
429
430        std::ostringstream s_iob_ram_wi;
431        s_iob_ram_wi << "iob_ram_wi_" << x_id << "_" << y_id;   
432        iob_ram_wi = new VciDspinInitiatorWrapper<vci_param_ext,
433                                                  dspin_ram_cmd_width,
434                                                  dspin_ram_rsp_width>(
435                     s_iob_ram_wi.str().c_str(),
436                     x_width + y_width + l_width);
437
438        ///////////// RAM LOCAL_XBAR(S)
439        std::ostringstream s_ram_xbar_cmd;
440        s_ram_xbar_cmd << "ram_xbar_cmd_" << x_id << "_" << y_id;   
441        ram_xbar_cmd = new DspinLocalCrossbar<dspin_ram_cmd_width>(
442                     s_ram_xbar_cmd.str().c_str(),
443                     mt_ram,                       // mapping table
444                     x_id, y_id,                   // cluster coordinates
445                     x_width, y_width, 0,          // one dest on ram_cmd network
446                     2,                            // number of local sources
447                     1,                            // number of local dests
448                     2, 2,                         // fifo depths 
449                     true,                         // CMD crossbar
450                     false,                        // no routing table (one dest)
451                     false );                      // no broadcast
452
453        std::ostringstream s_ram_xbar_rsp;
454        s_ram_xbar_rsp << "ram_xbar_rsp_" << x_id << "_" << y_id;   
455        ram_xbar_rsp = new DspinLocalCrossbar<dspin_ram_rsp_width>(
456                     s_ram_xbar_rsp.str().c_str(),
457                     mt_ram,                       // mapping table
458                     x_id, y_id,                   // cluster coordinates
459                     x_width, y_width, l_width,    // two sources on ram_rsp network
460                     1,                            // number of local sources
461                     2,                            // number of local dests
462                     2, 2,                         // fifo depths 
463                     false,                        // RSP crossbar
464                     true,                         // use routing table
465                     false );                      // no broadcast
466    }
467
468    ////////////////////////////////////
469    // Connections are defined here
470    ////////////////////////////////////
471
472    // on coherence network : local srcid[proc] in [0...nb_procs-1]
473    //                      : local srcid[memc] = nb_procs
474
475    //////////////////////// internal CMD & RSP routers
476    int_router_cmd->p_clk                        (this->p_clk);
477    int_router_cmd->p_resetn                     (this->p_resetn);
478    int_router_rsp->p_clk                        (this->p_clk);
479    int_router_rsp->p_resetn                     (this->p_resetn);
480
481    for (int i = 0; i < 4; i++)
482    {
483        for(int k = 0; k < 3; k++)
484        {
485            int_router_cmd->p_out[i][k]          (this->p_dspin_int_cmd_out[i][k]);
486            int_router_cmd->p_in[i][k]           (this->p_dspin_int_cmd_in[i][k]);
487        }
488
489        for(int k = 0; k < 2; k++)
490        {
491            int_router_rsp->p_out[i][k]          (this->p_dspin_int_rsp_out[i][k]);
492            int_router_rsp->p_in[i][k]           (this->p_dspin_int_rsp_in[i][k]);
493        }
494    }
495
496    // local ports
497    int_router_cmd->p_out[4][0]                  (signal_int_dspin_cmd_g2l_d);
498    int_router_cmd->p_out[4][1]                  (signal_int_dspin_m2p_g2l_c);
499    int_router_cmd->p_out[4][2]                  (signal_int_dspin_clack_g2l_c);
500    int_router_cmd->p_in[4][0]                   (signal_int_dspin_cmd_l2g_d);
501    int_router_cmd->p_in[4][1]                   (signal_int_dspin_m2p_l2g_c);
502    int_router_cmd->p_in[4][2]                   (signal_int_dspin_clack_l2g_c);
503   
504    int_router_rsp->p_out[4][0]                  (signal_int_dspin_rsp_g2l_d);
505    int_router_rsp->p_out[4][1]                  (signal_int_dspin_p2m_g2l_c);
506    int_router_rsp->p_in[4][0]                   (signal_int_dspin_rsp_l2g_d);
507    int_router_rsp->p_in[4][1]                   (signal_int_dspin_p2m_l2g_c);
508
509    ///////////////////// CMD DSPIN  local crossbar direct
510    int_xbar_cmd_d->p_clk                        (this->p_clk);
511    int_xbar_cmd_d->p_resetn                     (this->p_resetn);
512    int_xbar_cmd_d->p_global_out                 (signal_int_dspin_cmd_l2g_d);
513    int_xbar_cmd_d->p_global_in                  (signal_int_dspin_cmd_g2l_d);
514
515    int_xbar_cmd_d->p_local_out[memc_int_tgtid]  (signal_int_dspin_cmd_memc_t);
516    int_xbar_cmd_d->p_local_out[xicu_int_tgtid]  (signal_int_dspin_cmd_xicu_t);
517    int_xbar_cmd_d->p_local_out[mdma_int_tgtid]  (signal_int_dspin_cmd_mdma_t);
518
519    int_xbar_cmd_d->p_local_in[mdma_int_srcid]   (signal_int_dspin_cmd_mdma_i);
520
521    for (size_t p = 0; p < nb_procs; p++)
522    int_xbar_cmd_d->p_local_in[proc_int_srcid+p] (signal_int_dspin_cmd_proc_i[p]);
523
524    if ( (cluster_id == cluster_iob0) or (cluster_id == cluster_iob1) )
525    {
526    int_xbar_cmd_d->p_local_out[iobx_int_tgtid]  (signal_int_dspin_cmd_iobx_t);
527    int_xbar_cmd_d->p_local_in[iobx_int_srcid]   (signal_int_dspin_cmd_iobx_i);
528    }
529
530    //////////////////////// RSP DSPIN  local crossbar direct
531    int_xbar_rsp_d->p_clk                        (this->p_clk);
532    int_xbar_rsp_d->p_resetn                     (this->p_resetn);
533    int_xbar_rsp_d->p_global_out                 (signal_int_dspin_rsp_l2g_d);
534    int_xbar_rsp_d->p_global_in                  (signal_int_dspin_rsp_g2l_d);
535
536    int_xbar_rsp_d->p_local_in[memc_int_tgtid]   (signal_int_dspin_rsp_memc_t);
537    int_xbar_rsp_d->p_local_in[xicu_int_tgtid]   (signal_int_dspin_rsp_xicu_t);
538    int_xbar_rsp_d->p_local_in[mdma_int_tgtid]   (signal_int_dspin_rsp_mdma_t);
539
540    int_xbar_rsp_d->p_local_out[mdma_int_srcid]  (signal_int_dspin_rsp_mdma_i);
541
542    for (size_t p = 0; p < nb_procs; p++)
543    int_xbar_rsp_d->p_local_out[proc_int_srcid+p] (signal_int_dspin_rsp_proc_i[p]);
544
545    if ( (cluster_id == cluster_iob0) or (cluster_id == cluster_iob1) )
546    {
547    int_xbar_rsp_d->p_local_in[iobx_int_tgtid]   (signal_int_dspin_rsp_iobx_t);
548    int_xbar_rsp_d->p_local_out[iobx_int_srcid]  (signal_int_dspin_rsp_iobx_i);
549    }
550
551    ////////////////////// M2P DSPIN local crossbar coherence
552    int_xbar_m2p_c->p_clk                        (this->p_clk);
553    int_xbar_m2p_c->p_resetn                     (this->p_resetn);
554    int_xbar_m2p_c->p_global_out                 (signal_int_dspin_m2p_l2g_c);
555    int_xbar_m2p_c->p_global_in                  (signal_int_dspin_m2p_g2l_c);
556    int_xbar_m2p_c->p_local_in[0]                (signal_int_dspin_m2p_memc);
557    for (size_t p = 0; p < nb_procs; p++) 
558        int_xbar_m2p_c->p_local_out[p]           (signal_int_dspin_m2p_proc[p]);
559
560    ////////////////////////// P2M DSPIN local crossbar coherence
561    int_xbar_p2m_c->p_clk                        (this->p_clk);
562    int_xbar_p2m_c->p_resetn                     (this->p_resetn);
563    int_xbar_p2m_c->p_global_out                 (signal_int_dspin_p2m_l2g_c);
564    int_xbar_p2m_c->p_global_in                  (signal_int_dspin_p2m_g2l_c);
565    int_xbar_p2m_c->p_local_out[0]               (signal_int_dspin_p2m_memc);
566    for (size_t p = 0; p < nb_procs; p++) 
567        int_xbar_p2m_c->p_local_in[p]            (signal_int_dspin_p2m_proc[p]);
568
569    ////////////////////// CLACK DSPIN local crossbar coherence
570    int_xbar_clack_c->p_clk                      (this->p_clk);
571    int_xbar_clack_c->p_resetn                   (this->p_resetn);
572    int_xbar_clack_c->p_global_out               (signal_int_dspin_clack_l2g_c);
573    int_xbar_clack_c->p_global_in                (signal_int_dspin_clack_g2l_c);
574    int_xbar_clack_c->p_local_in[0]              (signal_int_dspin_clack_memc);
575    for (size_t p = 0; p < nb_procs; p++)
576        int_xbar_clack_c->p_local_out[p]         (signal_int_dspin_clack_proc[p]);
577
578    //////////////////////////////////// Processors
579    for (size_t p = 0; p < nb_procs; p++)
580    {
581        proc[p]->p_clk                           (this->p_clk);
582        proc[p]->p_resetn                        (this->p_resetn);
583        proc[p]->p_vci                           (signal_int_vci_ini_proc[p]);
584        proc[p]->p_dspin_m2p                     (signal_int_dspin_m2p_proc[p]);
585        proc[p]->p_dspin_p2m                     (signal_int_dspin_p2m_proc[p]);
586        proc[p]->p_dspin_clack                   (signal_int_dspin_clack_proc[p]);
587        proc[p]->p_irq[0]                        (signal_proc_it[p]);
588        for ( size_t j = 1 ; j < 6 ; j++)
589        {
590            proc[p]->p_irq[j]                    (signal_false);
591        }
592
593        proc_wi[p]->p_clk                        (this->p_clk);
594        proc_wi[p]->p_resetn                     (this->p_resetn);
595        proc_wi[p]->p_dspin_cmd                  (signal_int_dspin_cmd_proc_i[p]);
596        proc_wi[p]->p_dspin_rsp                  (signal_int_dspin_rsp_proc_i[p]);
597        proc_wi[p]->p_vci                        (signal_int_vci_ini_proc[p]);
598    }
599
600    ///////////////////////////////////// XICU
601    xicu->p_clk                                  (this->p_clk);
602    xicu->p_resetn                               (this->p_resetn);
603    xicu->p_vci                                  (signal_int_vci_tgt_xicu);
604    for ( size_t p=0 ; p<nb_procs ; p++)
605    {
606        xicu->p_irq[p]                           (signal_proc_it[p]);
607    }
608    for ( size_t i=0 ; i<4 ; i++)
609    {
610        xicu->p_hwi[i]                           (signal_irq_mdma[i]);
611    }
612    for ( size_t i=4 ; i<32 ; i++)
613    {
614        if (cluster_id == cluster_iob0) 
615        xicu->p_hwi[i]                           (*(this->p_irq[i]));
616        else 
617        xicu->p_hwi[i]                           (signal_false);
618    }                     
619
620    // wrapper XICU
621    xicu_int_wt->p_clk                           (this->p_clk);
622    xicu_int_wt->p_resetn                        (this->p_resetn);
623    xicu_int_wt->p_dspin_cmd                     (signal_int_dspin_cmd_xicu_t);
624    xicu_int_wt->p_dspin_rsp                     (signal_int_dspin_rsp_xicu_t);
625    xicu_int_wt->p_vci                           (signal_int_vci_tgt_xicu);
626
627    ///////////////////////////////////// MEMC
628    memc->p_clk                                  (this->p_clk);
629    memc->p_resetn                               (this->p_resetn);
630    memc->p_vci_ixr                              (signal_ram_vci_ini_memc);
631    memc->p_vci_tgt                              (signal_int_vci_tgt_memc);
632    memc->p_dspin_p2m                            (signal_int_dspin_p2m_memc);
633    memc->p_dspin_m2p                            (signal_int_dspin_m2p_memc);
634    memc->p_dspin_clack                          (signal_int_dspin_clack_memc);
635
636    // wrapper to INT network
637    memc_int_wt->p_clk                           (this->p_clk);
638    memc_int_wt->p_resetn                        (this->p_resetn);
639    memc_int_wt->p_dspin_cmd                     (signal_int_dspin_cmd_memc_t);
640    memc_int_wt->p_dspin_rsp                     (signal_int_dspin_rsp_memc_t);
641    memc_int_wt->p_vci                           (signal_int_vci_tgt_memc);
642
643    // wrapper to RAM network
644    memc_ram_wi->p_clk                           (this->p_clk);
645    memc_ram_wi->p_resetn                        (this->p_resetn);
646    memc_ram_wi->p_dspin_cmd                     (signal_ram_dspin_cmd_memc_i);
647    memc_ram_wi->p_dspin_rsp                     (signal_ram_dspin_rsp_memc_i);
648    memc_ram_wi->p_vci                           (signal_ram_vci_ini_memc);
649
650    //////////////////////////////////// XRAM
651    xram->p_clk                                  (this->p_clk);
652    xram->p_resetn                               (this->p_resetn);
653    xram->p_vci                                  (signal_ram_vci_tgt_xram);
654
655    // wrapper to RAM network
656    xram_ram_wt->p_clk                           (this->p_clk);
657    xram_ram_wt->p_resetn                        (this->p_resetn);
658    xram_ram_wt->p_dspin_cmd                     (signal_ram_dspin_cmd_xram_t);
659    xram_ram_wt->p_dspin_rsp                     (signal_ram_dspin_rsp_xram_t);
660    xram_ram_wt->p_vci                           (signal_ram_vci_tgt_xram);
661
662    /////////////////////////////////// MDMA
663    mdma->p_clk                                  (this->p_clk);
664    mdma->p_resetn                               (this->p_resetn);
665    mdma->p_vci_target                           (signal_int_vci_tgt_mdma);
666    mdma->p_vci_initiator                        (signal_int_vci_ini_mdma);
667    for (size_t i=0 ; i<nb_dmas ; i++)
668        mdma->p_irq[i]                           (signal_irq_mdma[i]);
669
670    // target wrapper
671    mdma_int_wt->p_clk                           (this->p_clk);
672    mdma_int_wt->p_resetn                        (this->p_resetn);
673    mdma_int_wt->p_dspin_cmd                     (signal_int_dspin_cmd_mdma_t);
674    mdma_int_wt->p_dspin_rsp                     (signal_int_dspin_rsp_mdma_t);
675    mdma_int_wt->p_vci                           (signal_int_vci_tgt_mdma);
676
677    // initiator wrapper
678    mdma_int_wi->p_clk                           (this->p_clk);
679    mdma_int_wi->p_resetn                        (this->p_resetn);
680    mdma_int_wi->p_dspin_cmd                     (signal_int_dspin_cmd_mdma_i);
681    mdma_int_wi->p_dspin_rsp                     (signal_int_dspin_rsp_mdma_i);
682    mdma_int_wi->p_vci                           (signal_int_vci_ini_mdma);
683
684    // For the IO bridge and the RAM network components, the connexions
685    // depend on cluster type: The vci_io_bridge and dspin_local_crossbar
686    // components are only in cluster_iob0 & cluster_iob1
687
688    if ( (cluster_id != cluster_iob0) and (cluster_id != cluster_iob1) )
689    {
690        // RAM network CMD & RSP routers
691        ram_router_cmd->p_clk                    (this->p_clk);
692        ram_router_cmd->p_resetn                 (this->p_resetn);
693        ram_router_rsp->p_clk                    (this->p_clk);
694        ram_router_rsp->p_resetn                 (this->p_resetn);
695        for( size_t n=0 ; n<4 ; n++)
696        {
697            ram_router_cmd->p_out[n]             (this->p_dspin_ram_cmd_out[n]);
698            ram_router_cmd->p_in[n]              (this->p_dspin_ram_cmd_in[n]);
699            ram_router_rsp->p_out[n]             (this->p_dspin_ram_rsp_out[n]);
700            ram_router_rsp->p_in[n]              (this->p_dspin_ram_rsp_in[n]);
701        }
702        ram_router_cmd->p_out[4]                 (signal_ram_dspin_cmd_xram_t);
703        ram_router_cmd->p_in[4]                  (signal_ram_dspin_cmd_memc_i);
704        ram_router_rsp->p_out[4]                 (signal_ram_dspin_rsp_memc_i);
705        ram_router_rsp->p_in[4]                  (signal_ram_dspin_rsp_xram_t);
706    }
707    else  // IO cluster
708    {
709        // IO bridge
710        iob->p_clk                               (this->p_clk);
711        iob->p_resetn                            (this->p_resetn);
712        iob->p_vci_ini_iox                       (*(this->p_vci_iox_ini));
713        iob->p_vci_tgt_iox                       (*(this->p_vci_iox_tgt));
714        iob->p_vci_tgt_int                       (signal_int_vci_tgt_iobx);
715        iob->p_vci_ini_int                       (signal_int_vci_ini_iobx);
716        iob->p_vci_ini_ram                       (signal_ram_vci_ini_iobx);
717        if ( cluster_id == cluster_iob0 )
718            for ( size_t n=0 ; n<32 ; n++ )
719                (*iob->p_irq[n])                 (*(this->p_irq[n]));
720
721        // initiator wrapper to RAM network
722        iob_ram_wi->p_clk                        (this->p_clk);
723        iob_ram_wi->p_resetn                     (this->p_resetn);
724        iob_ram_wi->p_dspin_cmd                  (signal_ram_dspin_cmd_iobx_i);
725        iob_ram_wi->p_dspin_rsp                  (signal_ram_dspin_rsp_iobx_i);
726        iob_ram_wi->p_vci                        (signal_ram_vci_ini_iobx);
727
728        // initiator wrapper to INT network
729        iob_int_wi->p_clk                        (this->p_clk);
730        iob_int_wi->p_resetn                     (this->p_resetn);
731        iob_int_wi->p_dspin_cmd                  (signal_int_dspin_cmd_iobx_i);
732        iob_int_wi->p_dspin_rsp                  (signal_int_dspin_rsp_iobx_i);
733        iob_int_wi->p_vci                        (signal_int_vci_ini_iobx);
734
735        // target wrapper to INT network
736        iob_int_wt->p_clk                        (this->p_clk);
737        iob_int_wt->p_resetn                     (this->p_resetn);
738        iob_int_wt->p_dspin_cmd                  (signal_int_dspin_cmd_iobx_t);
739        iob_int_wt->p_dspin_rsp                  (signal_int_dspin_rsp_iobx_t);
740        iob_int_wt->p_vci                        (signal_int_vci_tgt_iobx);
741
742        // RAM network CMD local crossbar
743        ram_xbar_cmd->p_clk                      (this->p_clk);
744        ram_xbar_cmd->p_resetn                   (this->p_resetn);
745        ram_xbar_cmd->p_global_out               (signal_ram_dspin_cmd_l2g);
746        ram_xbar_cmd->p_global_in                (signal_ram_dspin_cmd_g2l);
747        ram_xbar_cmd->p_local_in[0]              (signal_ram_dspin_cmd_memc_i);
748        ram_xbar_cmd->p_local_in[1]              (signal_ram_dspin_cmd_iobx_i);
749        ram_xbar_cmd->p_local_out[0]             (signal_ram_dspin_cmd_xram_t);
750
751        // RAM network RSP local crossbar
752        ram_xbar_rsp->p_clk                      (this->p_clk);
753        ram_xbar_rsp->p_resetn                   (this->p_resetn);
754        ram_xbar_rsp->p_global_out               (signal_ram_dspin_rsp_l2g);
755        ram_xbar_rsp->p_global_in                (signal_ram_dspin_rsp_g2l);
756        ram_xbar_rsp->p_local_in[0]              (signal_ram_dspin_rsp_xram_t);
757        ram_xbar_rsp->p_local_out[0]             (signal_ram_dspin_rsp_memc_i);
758        ram_xbar_rsp->p_local_out[1]             (signal_ram_dspin_rsp_iobx_i);
759
760        // RAM network CMD & RSP routers
761        ram_router_cmd->p_clk                    (this->p_clk);
762        ram_router_cmd->p_resetn                 (this->p_resetn);
763        ram_router_rsp->p_clk                    (this->p_clk);
764        ram_router_rsp->p_resetn                 (this->p_resetn);
765        for( size_t n=0 ; n<4 ; n++)
766        {
767            ram_router_cmd->p_out[n]             (this->p_dspin_ram_cmd_out[n]);
768            ram_router_cmd->p_in[n]              (this->p_dspin_ram_cmd_in[n]);
769            ram_router_rsp->p_out[n]             (this->p_dspin_ram_rsp_out[n]);
770            ram_router_rsp->p_in[n]              (this->p_dspin_ram_rsp_in[n]);
771        }
772        ram_router_cmd->p_out[4]                 (signal_ram_dspin_cmd_g2l);
773        ram_router_cmd->p_in[4]                  (signal_ram_dspin_cmd_l2g);
774        ram_router_rsp->p_out[4]                 (signal_ram_dspin_rsp_g2l);
775        ram_router_rsp->p_in[4]                  (signal_ram_dspin_rsp_l2g);
776    }
777   
778} // end constructor
779
780}}
781
782
783// Local Variables:
784// tab-width: 3
785// c-basic-offset: 3
786// c-file-offsets:((innamespace . 0)(inline-open . 0))
787// indent-tabs-mode: nil
788// End:
789
790// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
791
792
793
Note: See TracBrowser for help on using the repository browser.