source: branches/v5/platforms/tsar_generic_mmu/tsar_cluster_mmu/caba/source/src/tsar_cluster_mmu.cpp @ 351

Last change on this file since 351 was 351, checked in by joannou, 11 years ago

Got rid of intermediate v5 version. _dspin_coherence versions changed to main version for v5. Changed components names and platforms to fit the new names

File size: 23.7 KB
Line 
1//////////////////////////////////////////////////////////////////////////////
2// File: tsar_cluster_mmu.c
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 the virtual_dspin_router as distributed global interconnect
10// - It uses the vci_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, and the boot BROM are in the cluster
18//   containing address 0xBFC00000.
19// - The Multi-TTY component controls up to 15 terminals.
20// - Each Multi-DMA component controls up to 8 DMA channels.
21// - The DMA IRQs are connected to IRQ_IN[8]...IRQ_IN[15]
22// - The TTY IRQs are connected to IRQ_IN[16]...IRQ_IN[30]
23// - The BDEV IRQ is connected to IRQ_IN[31]
24//////////////////////////////////////////////////////////////////////////////////
25
26#include "../include/tsar_cluster_mmu.h"
27
28namespace soclib {
29namespace caba  {
30
31//////////////////////////////////////////////////////////////////////////
32//                 Constructor
33//////////////////////////////////////////////////////////////////////////
34template<typename vci_param, typename iss_t, int cmd_width, int rsp_width>
35TsarClusterMmu<vci_param, iss_t, cmd_width, rsp_width>::TsarClusterMmu(
36         sc_module_name                     insname,
37         size_t                             nb_procs,
38         size_t                             nb_ttys,
39         size_t                             nb_dmas,
40         size_t                             x_id,
41         size_t                             y_id,
42         size_t                             cluster_id,
43         const soclib::common::MappingTable &mtd,
44         const soclib::common::MappingTable &mtx, 
45         size_t                             x_width,
46         size_t                             y_width,
47         size_t                             l_width,
48         size_t                             tgtid_memc,
49         size_t                             tgtid_xicu,
50         size_t                             tgtid_mdma,
51         size_t                             tgtid_fbuf,
52         size_t                             tgtid_mtty,
53         size_t                             tgtid_brom,
54         size_t                             tgtid_mnic,
55         size_t                             tgtid_bdev,
56         size_t                             memc_ways,
57         size_t                             memc_sets,
58         size_t                             l1_i_ways,
59         size_t                             l1_i_sets,
60         size_t                             l1_d_ways,
61         size_t                             l1_d_sets,
62         size_t                             xram_latency,
63         bool                               io,
64         size_t                             xfb,
65         size_t                             yfb,
66         char*                              disk_name,
67         size_t                             block_size,
68         size_t                             nic_channels,
69         char*                              nic_rx_name,
70         char*                              nic_tx_name,
71         uint32_t                           nic_timeout,
72         const Loader                      &loader,
73         uint32_t                           frozen_cycles,
74         uint32_t                           debug_start_cycle,
75         bool                               memc_debug_ok,
76         bool                               proc_debug_ok)
77            : soclib::caba::BaseModule(insname),
78            p_clk("clk"),
79            p_resetn("resetn")
80
81{
82    // Vectors of ports definition
83
84    p_cmd_in        = alloc_elems<DspinInput<cmd_width> >("p_cmd_in", 2, 4);
85    p_cmd_out       = alloc_elems<DspinOutput<cmd_width> >("p_cmd_out", 2, 4);
86    p_rsp_in        = alloc_elems<DspinInput<rsp_width> >("p_rsp_in", 2, 4);
87    p_rsp_out       = alloc_elems<DspinOutput<rsp_width> >("p_rsp_out", 2, 4);
88
89    // Components definition
90
91    // on direct network : local srcid[proc] in [0..nb_procs-1]
92    // on direct network : local srcid[mdma] = nb_procs
93    // on direct network : local srcid[bdev] = nb_procs + 1
94
95    // on coherence network : local srcid[proc] in [0...nb_procs-1]
96    // on coherence network : local srcid[memc] = nb_procs
97
98    std::cout << "  - building proc_" << x_id << "_" << y_id << "-*" << std::endl;
99
100    for (size_t p = 0; p < nb_procs; p++)
101    { 
102        std::ostringstream sproc;
103        sproc << "proc_" << x_id << "_" << y_id << "_" << p;
104        proc[p] = new VciCcVCacheWrapper<vci_param, iss_t>(
105                      sproc.str().c_str(),
106                      cluster_id*nb_procs + p,
107                      mtd,                            // Mapping Table Direct
108                      IntTab(cluster_id,p),           // SRCID_D
109                      (cluster_id << l_width) + p,    // CC_GLOBAL_ID
110                      8,                              // ITLB ways
111                      8,                              // ITLB sets
112                      8,                              // DTLB ways
113                      8,                              // DTLB sets
114                      l1_i_ways,l1_i_sets,16,         // ICACHE size
115                      l1_d_ways,l1_d_sets,16,         // DCACHE size
116                      4,                              // WBUF nlines
117                      4,                              // WBUF nwords
118                      x_width,
119                      y_width,
120                      frozen_cycles,                  // max frozen cycles
121                      debug_start_cycle,
122                      proc_debug_ok);
123    }
124
125    std::cout << "  - building memc_" << x_id << "_" << y_id << std::endl;
126
127    std::ostringstream smemc;
128    smemc << "memc_" << x_id << "_" << y_id;
129    memc = new VciMemCache<vci_param>(
130                     smemc.str().c_str(),
131                     mtd, mtx,
132                     IntTab(cluster_id),              // SRCID_X
133                     IntTab(cluster_id, tgtid_memc),  // TGTID_D
134                     (cluster_id << l_width) + nb_procs, // CC_GLOBAL_ID
135                     memc_ways, memc_sets, 16,        // CACHE SIZE
136                     3,                                  // MAX NUMBER OF COPIES
137                     256,                            // HEAP SIZE
138                     8,                               // TRANSACTION TABLE DEPTH
139                     8,                               // UPDATE TABLE DEPTH
140                     debug_start_cycle,
141                     memc_debug_ok);
142
143    std::cout << "  - building xram_" << x_id << "_" << y_id << std::endl;
144
145    std::ostringstream sxram;
146    sxram << "xram_" << x_id << "_" << y_id;
147    xram = new VciSimpleRam<vci_param>(
148                     sxram.str().c_str(),
149                     IntTab(cluster_id),
150                     mtx,
151                     loader,
152                     xram_latency);
153
154    std::cout << "  - building xicu_" << x_id << "_" << y_id << std::endl;
155
156    std::ostringstream sicu;
157    sicu << "xicu_" << x_id << "_" << y_id;
158    xicu = new VciXicu<vci_param>(
159                     sicu.str().c_str(),
160                     mtd,                               // mapping table
161                     IntTab(cluster_id, tgtid_xicu),    // TGTID_D
162                     nb_procs,                          // number of timer IRQs
163                     32,                                // number of hard IRQs
164                     32,                                // number of soft IRQs
165                     nb_procs);                         // number of output IRQs
166
167    std::cout << "  - building dma_" << x_id << "_" << y_id << std::endl;
168
169    std::ostringstream sdma;
170    sdma << "dma_" << x_id << "_" << y_id;
171    mdma = new VciMultiDma<vci_param>(
172                     sdma.str().c_str(),
173                     mtd,
174                     IntTab(cluster_id, nb_procs),        // SRCID
175                     IntTab(cluster_id, tgtid_mdma),      // TGTID
176                     64,                                  // burst size
177                     nb_dmas);                           // number of IRQs
178
179    std::cout << "  - building xbard_" << x_id << "_" << y_id << std::endl;
180
181    size_t nb_direct_initiators      = nb_procs + 1;
182    size_t nb_direct_targets         = 3;
183    if ( io )
184    {
185        nb_direct_initiators         = nb_procs + 2;
186        nb_direct_targets            = 8;
187    }
188    std::ostringstream sd;
189    sd << "xbard_" << x_id << "_" << y_id;
190    xbard = new VciLocalCrossbar<vci_param>(
191                     sd.str().c_str(),
192                     mtd,
193                     IntTab(cluster_id),           // cluster initiator index
194                     IntTab(cluster_id),           // cluster target index
195                     nb_direct_initiators,         // number of initiators
196                     nb_direct_targets);           // number of targets     
197
198    std::cout << "  - building ringc_" << x_id << "_" << y_id << std::endl;
199
200    std::ostringstream sc;
201    sc << "ringc_" << x_id << "_" << y_id;
202        //ringc = new soclib::caba::DspinLocalRingFastC<vci_param, 40, 33>(sc.str().c_str(),mtc, IntTab(cluster_id), 2, 2, 2, nb_procs + 1, x_width, y_width);
203        //
204   // coherence network
205   // - tgtid_c_proc = srcid_c_proc = local procid
206   // - tgtid_c_memc = srcid_c_memc = NB_PROCS_MAX
207#define address_width         32
208#define srcid_width           14
209#include "../../../../giet_vm/hard_config.h"
210#define cluster(x,y)   (y + CLUSTER_Y*x)
211   MappingTable maptabc(address_width, 
212         IntTab(x_width + y_width, srcid_width - x_width - y_width), 
213         IntTab(x_width + y_width, srcid_width - x_width - y_width), 
214         0x00FF0000);
215
216   for (size_t x = 0; x < CLUSTER_X; x++)
217   {
218      for (size_t y = 0; y < CLUSTER_Y; y++)
219      {
220         sc_uint<address_width> offset  = cluster(x,y) << (address_width-x_width-y_width);
221
222         // cleanup requests must be routed to the memory cache
223         std::ostringstream sh;
224         sh << "c_seg_memc_" << x << "_" << y;
225         maptabc.add(Segment(sh.str(), (NB_PROCS_MAX << (address_width - srcid_width)) + offset, 
226                     0x10, IntTab(cluster(x,y), NB_PROCS_MAX), false));
227
228         // update & invalidate requests must be routed to the proper processor
229         for ( size_t p = 0 ; p < NB_PROCS_MAX ; p++) 
230         {
231            std::ostringstream sp;
232            sp << "c_seg_proc_" << x << "_" << y << "_" << p;
233            maptabc.add( Segment( sp.str() , (p << (address_width - srcid_width)) + offset , 
234                         0x10 , IntTab(cluster(x,y), p) , false)); 
235         }
236      }
237   }
238   std::cout << maptabc << std::endl;
239        //
240        //
241        //
242        ringc = new soclib::caba::DspinLocalRingFastC<vci_param, 40, 33>(sc.str().c_str(),maptabc, IntTab(cluster_id), 2, 2, 1, nb_procs, x_width, y_width);
243
244    std::cout << "  - building wrappers in cluster_" << x_id << "_" << y_id << std::endl;
245
246    std::ostringstream wid;
247    wid << "iniwrapperd_" << x_id << "_" << y_id;
248    iniwrapperd = new VciVdspinInitiatorWrapper<vci_param,cmd_width,rsp_width>(
249                     wid.str().c_str(),
250                     4,                            // cmd fifo depth
251                     4);                           // rsp fifo depth
252
253    std::ostringstream wtd;
254    wtd << "tgtwrapperd_" << x_id << "_" << y_id;
255    tgtwrapperd = new VciVdspinTargetWrapper<vci_param,cmd_width,rsp_width>(
256                     wtd.str().c_str(),
257                     4,                            // cmd fifo depth
258                     4);                           // rsp fifo depth
259
260    std::cout << "  - building cmdrouter_" << x_id << "_" << y_id << std::endl;
261
262    std::ostringstream scmd;
263    scmd << "cmdrouter_" << x_id << "_" << y_id;
264    cmdrouter = new VirtualDspinRouter<cmd_width>(
265                     scmd.str().c_str(),
266                     x_id,y_id,                    // coordinate in the mesh
267                     x_width, y_width,             // x & y fields width
268                     4,4);                         // input & output fifo depths
269
270    std::cout << "  - building rsprouter_" << x_id << "_" << y_id << std::endl;
271
272    std::ostringstream srsp;
273    srsp << "rsprouter_" << x_id << "_" << y_id;
274    rsprouter = new VirtualDspinRouter<rsp_width>(
275                     srsp.str().c_str(),
276                     x_id,y_id,                    // coordinates in mesh
277                     x_width, y_width,             // x & y fields width
278                     4,4);                         // input & output fifo depths
279
280    // IO cluster components
281    if ( io )
282    {
283        std::cout << "  - building brom" << std::endl;
284
285        brom = new VciSimpleRam<vci_param>(
286                        "brom",
287                        IntTab(cluster_id, tgtid_brom),
288                        mtd,
289                        loader);
290
291        std::cout << "  - building fbuf" << std::endl;
292
293        fbuf = new VciFrameBuffer<vci_param>(
294                        "fbuf",
295                        IntTab(cluster_id, tgtid_fbuf),
296                        mtd,
297                        xfb, yfb); 
298
299        std::cout << "  - building fbuf" << std::endl;
300
301        bdev = new VciBlockDeviceTsarV4<vci_param>(
302                        "bdev",
303                        mtd,
304                        IntTab(cluster_id, nb_procs+1),
305                        IntTab(cluster_id, tgtid_bdev),
306                        disk_name,
307                        block_size,
308                        64);            // burst size
309
310        std::cout << "  - building mnic" << std::endl;
311
312        mnic = new VciMultiNic<vci_param>(
313                        "mnic",
314                        IntTab(cluster_id, tgtid_mnic),
315                        mtd,
316                        nic_channels,
317                        nic_rx_name,
318                        nic_tx_name,
319                        0,   // default mac address MAC4
320                        0 ); // default mac address MAC2
321
322        std::cout << "  - building mtty" << std::endl;
323
324        std::vector<std::string> vect_names;
325        for( size_t tid = 0 ; tid < (nb_ttys) ; tid++ )
326        {
327            std::ostringstream term_name;
328            term_name <<  "term" << tid;
329            vect_names.push_back(term_name.str().c_str());
330        }
331        mtty = new VciMultiTty<vci_param>(
332                        "mtty",
333                        IntTab(cluster_id, tgtid_mtty),
334                        mtd, 
335                        vect_names);
336    }
337
338    std::cout << std::endl;
339
340    ////////////////////////////////////
341    // Connections are defined here
342    ////////////////////////////////////
343
344    // CMDROUTER and RSPROUTER
345    cmdrouter->p_clk                        (this->p_clk);
346    cmdrouter->p_resetn                     (this->p_resetn);
347    rsprouter->p_clk                        (this->p_clk);
348    rsprouter->p_resetn                     (this->p_resetn);
349    for (int x = 0; x < 2; x++)
350    {
351        for(int y = 0; y < 4; y++)
352        {
353            cmdrouter->p_out[x][y]          (this->p_cmd_out[x][y]);
354            cmdrouter->p_in[x][y]           (this->p_cmd_in[x][y]);
355            rsprouter->p_out[x][y]          (this->p_rsp_out[x][y]);
356            rsprouter->p_in[x][y]           (this->p_rsp_in[x][y]);
357        }
358    }
359
360    cmdrouter->p_out[0][4]                  (signal_dspin_cmd_g2l_d);
361    cmdrouter->p_out[1][4]                  (signal_dspin_cmd_g2l_c);
362    cmdrouter->p_in[0][4]                   (signal_dspin_cmd_l2g_d);
363    cmdrouter->p_in[1][4]                   (signal_dspin_cmd_l2g_c);
364
365    rsprouter->p_out[0][4]                  (signal_dspin_rsp_g2l_d);
366    rsprouter->p_out[1][4]                  (signal_dspin_rsp_g2l_c);
367    rsprouter->p_in[0][4]                   (signal_dspin_rsp_l2g_d);
368    rsprouter->p_in[1][4]                   (signal_dspin_rsp_l2g_c);
369
370    std::cout << "  - CMD & RSP routers connected" << std::endl;
371
372    // VCI/DSPIN WRAPPERS
373    iniwrapperd->p_clk                      (this->p_clk);
374    iniwrapperd->p_resetn                   (this->p_resetn);
375    iniwrapperd->p_vci                      (signal_vci_l2g_d);
376    iniwrapperd->p_dspin_out                (signal_dspin_cmd_l2g_d);
377    iniwrapperd->p_dspin_in                 (signal_dspin_rsp_g2l_d);
378
379    tgtwrapperd->p_clk                      (this->p_clk);
380    tgtwrapperd->p_resetn                   (this->p_resetn);
381    tgtwrapperd->p_vci                      (signal_vci_g2l_d);
382    tgtwrapperd->p_dspin_out                (signal_dspin_rsp_l2g_d);
383    tgtwrapperd->p_dspin_in                 (signal_dspin_cmd_g2l_d);
384
385    std::cout << "  - VCI/DSPIN wrappers connected" << std::endl;
386
387    // CROSSBAR direct
388    xbard->p_clk                            (this->p_clk);
389    xbard->p_resetn                         (this->p_resetn);
390    xbard->p_initiator_to_up                (signal_vci_l2g_d);
391    xbard->p_target_to_up                   (signal_vci_g2l_d);
392
393    xbard->p_to_target[tgtid_memc]          (signal_vci_tgt_d_memc);
394    xbard->p_to_target[tgtid_xicu]          (signal_vci_tgt_d_xicu);
395    xbard->p_to_target[tgtid_mdma]          (signal_vci_tgt_d_mdma);
396
397    xbard->p_to_initiator[nb_procs]         (signal_vci_ini_d_mdma);
398
399    for (size_t p = 0; p < nb_procs; p++)
400    {
401        xbard->p_to_initiator[p]            (signal_vci_ini_d_proc[p]);
402    }
403
404    if ( io )
405    {
406        xbard->p_to_target[tgtid_mtty]      (signal_vci_tgt_d_mtty);
407        xbard->p_to_target[tgtid_brom]      (signal_vci_tgt_d_brom);
408        xbard->p_to_target[tgtid_bdev]      (signal_vci_tgt_d_bdev);
409        xbard->p_to_target[tgtid_fbuf]      (signal_vci_tgt_d_fbuf);
410        xbard->p_to_target[tgtid_mnic]      (signal_vci_tgt_d_mnic);
411
412        xbard->p_to_initiator[nb_procs+1]   (signal_vci_ini_d_bdev);
413    }
414
415    std::cout << "  - Direct crossbar connected" << std::endl;
416
417    // RING coherence
418    ringc->p_clk                            (this->p_clk);
419    ringc->p_resetn                         (this->p_resetn);
420    //ringc procs
421    for (size_t p = 0; p < nb_procs; p++) 
422    {
423       ringc->p_rsp_in[p](signal_dspin_c_from_proc[p]);
424       ringc->p_cmd_out[p](signal_dspin_c_to_proc[p]);
425    }
426    //ringc memc
427    ringc->p_cmd_in[0](signal_dspin_c_from_memc);
428    ringc->p_rsp_out[0](signal_dspin_c_to_memc);
429    //ringc router
430    ringc->p_cmd_in[1](signal_dspin_cmd_g2l_c);
431    ringc->p_rsp_in[nb_procs](signal_dspin_rsp_g2l_c);
432    ringc->p_cmd_out[nb_procs](signal_dspin_cmd_l2g_c);
433    ringc->p_rsp_out[1](signal_dspin_rsp_l2g_c);
434
435    std::cout << "  - Coherence ring connected" << std::endl;
436
437    // Processors
438    for (size_t p = 0; p < nb_procs; p++)
439    {
440        proc[p]->p_clk                      (this->p_clk);
441        proc[p]->p_resetn                   (this->p_resetn);
442        proc[p]->p_vci                      (signal_vci_ini_d_proc[p]);
443        proc[p]->p_dspin_in                 (signal_dspin_c_to_proc[p]);
444        proc[p]->p_dspin_out                (signal_dspin_c_from_proc[p]);
445        proc[p]->p_irq[0]                   (signal_proc_it[p]);
446        for ( size_t j = 1 ; j < 6 ; j++)
447        {
448            proc[p]->p_irq[j]               (signal_false);
449        }
450    }
451
452    std::cout << "  - Processors connected" << std::endl;
453
454    // XICU
455    xicu->p_clk                         (this->p_clk);
456    xicu->p_resetn                      (this->p_resetn);
457    xicu->p_vci                         (signal_vci_tgt_d_xicu);
458    for ( size_t p=0 ; p<nb_procs ; p++)
459    {
460        xicu->p_irq[p]                  (signal_proc_it[p]);
461    }
462    for ( size_t i=0 ; i<32 ; i++)
463    {
464        if ( io ) // I/O cluster
465        {
466            if      (i < 8)                  xicu->p_hwi[i] (signal_false);
467            else if (i < (8 + nb_dmas))      xicu->p_hwi[i]     (signal_irq_mdma[i-8]);
468            else if (i < 16)                 xicu->p_hwi[i] (signal_false);
469            else if (i < (16 + nb_ttys))     xicu->p_hwi[i] (signal_irq_mtty[i-16]);
470            else if (i < 31)                 xicu->p_hwi[i]     (signal_false);
471            else                             xicu->p_hwi[i] (signal_irq_bdev);
472        }
473        else      // other clusters
474        {
475            if      (i < 8)                  xicu->p_hwi[i] (signal_false);
476            else if (i < (8 + nb_dmas))      xicu->p_hwi[i]     (signal_irq_mdma[i-8]);
477            else                             xicu->p_hwi[i]     (signal_false);
478        }
479    }
480
481    std::cout << "  - XICU connected" << std::endl;
482
483    // MEMC
484    memc->p_clk                         (this->p_clk);
485    memc->p_resetn                      (this->p_resetn);
486    memc->p_vci_ixr                     (signal_vci_xram);
487    memc->p_vci_tgt                     (signal_vci_tgt_d_memc);
488    memc->p_dspin_in                    (signal_dspin_c_to_memc);
489    memc->p_dspin_out                   (signal_dspin_c_from_memc);
490
491    std::cout << "  - MEMC connected" << std::endl;
492
493    // XRAM
494    xram->p_clk                         (this->p_clk);
495    xram->p_resetn                      (this->p_resetn);
496    xram->p_vci                               (signal_vci_xram);
497
498    std::cout << "  - XRAM connected" << std::endl;
499
500    // CDMA
501    mdma->p_clk                         (this->p_clk);
502    mdma->p_resetn                      (this->p_resetn);
503    mdma->p_vci_target                  (signal_vci_tgt_d_mdma);
504    mdma->p_vci_initiator               (signal_vci_ini_d_mdma);
505    for (size_t i=0 ; i<nb_dmas ; i++)
506    {
507        mdma->p_irq[i]                  (signal_irq_mdma[i]);
508    }
509
510    std::cout << "  - MDMA connected" << std::endl;
511
512         // Components in I/O cluster
513
514         if ( io )
515         {
516        // BDEV           
517             bdev->p_clk                    (this->p_clk);
518        bdev->p_resetn                 (this->p_resetn);
519        bdev->p_irq                    (signal_irq_bdev);
520        bdev->p_vci_target             (signal_vci_tgt_d_bdev);
521        bdev->p_vci_initiator          (signal_vci_ini_d_bdev);
522
523        std::cout << "  - BDEV connected" << std::endl;
524
525        // FBUF
526        fbuf->p_clk                    (this->p_clk);
527        fbuf->p_resetn                 (this->p_resetn);
528        fbuf->p_vci                    (signal_vci_tgt_d_fbuf);
529
530        std::cout << "  - FBUF connected" << std::endl;
531
532        // MNIC
533        mnic->p_clk                    (this->p_clk);
534        mnic->p_resetn                 (this->p_resetn);
535        mnic->p_vci                    (signal_vci_tgt_d_mnic);
536        for ( size_t i=0 ; i<nic_channels ; i++ )
537        {
538            mnic->p_rx_irq[i]          (signal_irq_mnic_rx[i]);
539            mnic->p_tx_irq[i]          (signal_irq_mnic_tx[i]);
540        }
541
542        std::cout << "  - MNIC connected" << std::endl;
543
544        // BROM
545        brom->p_clk                    (this->p_clk);
546        brom->p_resetn                 (this->p_resetn);
547        brom->p_vci                    (signal_vci_tgt_d_brom);
548
549        std::cout << "  - BROM connected" << std::endl;
550
551        // MTTY
552        mtty->p_clk                    (this->p_clk);
553        mtty->p_resetn                 (this->p_resetn);
554        mtty->p_vci                    (signal_vci_tgt_d_mtty);
555        for ( size_t i=0 ; i<nb_ttys ; i++ )
556        {
557            mtty->p_irq[i]              (signal_irq_mtty[i]);
558        }
559
560        std::cout << "  - MTTY connected" << std::endl;
561   }
562} // end constructor
563
564///////////////////////////////////////////////////////////////////////////
565//    destructor
566///////////////////////////////////////////////////////////////////////////
567template<typename vci_param, typename iss_t, int cmd_width, int rsp_width>
568TsarClusterMmu<vci_param, iss_t, cmd_width, rsp_width>::~TsarClusterMmu() {}
569
570}
571}
572
573
574// Local Variables:
575// tab-width: 3
576// c-basic-offset: 3
577// c-file-offsets:((innamespace . 0)(inline-open . 0))
578// indent-tabs-mode: nil
579// End:
580
581// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
582
583
584
Note: See TracBrowser for help on using the repository browser.