source: branches/fault_tolerance/platform/tsar_generic_iob/tsar_iob_cluster/caba/source/src/tsar_iob_cluster.cpp @ 648

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

Introducing new platform with IO bridges in fault_tolerance
branch

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