source: trunk/platforms/tsar_generic_xbar/top.cpp @ 509

Last change on this file since 509 was 508, checked in by meunier, 11 years ago
File size: 36.5 KB
Line 
1/////////////////////////////////////////////////////////////////////////
2// File: top.cpp
3// Author: Alain Greiner
4// Copyright: UPMC/LIP6
5// Date : may 2013
6// This program is released under the GNU public license
7/////////////////////////////////////////////////////////////////////////
8// This file define a generic TSAR architecture.
9// The physical address space is 40 bits.
10//
11// The number of clusters cannot be larger than 256.
12// The number of processors per cluster cannot be larger than 8.
13//
14// - It uses four dspin_local_crossbar per cluster as local interconnect
15// - It uses two virtual_dspin routers per cluster as global interconnect
16// - It uses the vci_cc_vcache_wrapper
17// - It uses the vci_mem_cache
18// - It contains one vci_xicu per cluster.
19// - It contains one vci_multi_dma per cluster.
20// - It contains one vci_simple_ram per cluster to model the L3 cache.
21//
22// The communication between the MemCache and the Xram is 64 bits.
23//
24// All clusters are identical, but the cluster 0 (called io_cluster),
25// contains 6 extra components:
26// - the boot rom (BROM)
27// - the disk controller (BDEV)
28// - the multi-channel network controller (MNIC)
29// - the multi-channel chained buffer dma controller (CDMA)
30// - the multi-channel tty controller (MTTY)
31// - the frame buffer controller (FBUF)
32//
33// It is build with one single component implementing a cluster,
34// defined in files tsar_xbar_cluster.* (with * = cpp, h, sd)
35//
36// The IRQs are connected to XICUs as follow:
37// - The IRQ_IN[0] to IRQ_IN[7] ports are not used in all clusters.
38// - The DMA IRQs are connected to IRQ_IN[8] to IRQ_IN[15] in all clusters.
39// - The TTY IRQs are connected to IRQ_IN[16] to IRQ_IN[30] in I/O cluster.
40// - The BDEV IRQ is connected to IRQ_IN[31] in I/O cluster.
41//
42// Some hardware parameters are used when compiling the OS, and are used
43// by this top.cpp file. They must be defined in the hard_config.h file :
44// - CLUSTER_X        : number of clusters in a row (power of 2)
45// - CLUSTER_Y        : number of clusters in a column (power of 2)
46// - CLUSTER_SIZE     : size of the segment allocated to a cluster
47// - NB_PROCS_MAX     : number of processors per cluster (power of 2)
48// - NB_DMA_CHANNELS  : number of DMA channels per cluster (< 9)
49// - NB_TTY_CHANNELS  : number of TTY channels in I/O cluster (< 16)
50// - NB_NIC_CHANNELS  : number of NIC channels in I/O cluster (< 9)
51//
52// Some other hardware parameters are not used when compiling the OS,
53// and can be directly defined in this top.cpp file:
54// - XRAM_LATENCY     : external ram latency
55// - MEMC_WAYS        : L2 cache number of ways
56// - MEMC_SETS        : L2 cache number of sets
57// - L1_IWAYS     
58// - L1_ISETS   
59// - L1_DWAYS   
60// - L1_DSETS 
61// - FBUF_X_SIZE      : width of frame buffer (pixels)
62// - FBUF_Y_SIZE      : heigth of frame buffer (lines)
63// - BDEV_SECTOR_SIZE : block size for block drvice
64// - BDEV_IMAGE_NAME  : file pathname for block device
65// - NIC_RX_NAME      : file pathname for NIC received packets
66// - NIC_TX_NAME      : file pathname for NIC transmited packets
67// - NIC_TIMEOUT      : max number of cycles before closing a container
68/////////////////////////////////////////////////////////////////////////
69// General policy for 40 bits physical address decoding:
70// All physical segments base addresses are multiple of 1 Mbytes
71// (=> the 24 LSB bits = 0, and the 16 MSB bits define the target)
72// The (x_width + y_width) MSB bits (left aligned) define
73// the cluster index, and the LADR bits define the local index:
74//      | X_ID  | Y_ID  |---| LADR |     OFFSET          |
75//      |x_width|y_width|---|  8   |       24            |
76/////////////////////////////////////////////////////////////////////////
77// General policy for 14 bits SRCID decoding:
78// Each component is identified by (x_id, y_id, l_id) tuple.
79//      | X_ID  | Y_ID  |---| L_ID |
80//      |x_width|y_width|---|  6   |
81/////////////////////////////////////////////////////////////////////////
82
83#include <systemc>
84#include <sys/time.h>
85#include <iostream>
86#include <sstream>
87#include <cstdlib>
88#include <cstdarg>
89#include <stdint.h>
90
91#include "gdbserver.h"
92#include "mapping_table.h"
93#include "tsar_xbar_cluster.h"
94#include "alloc_elems.h"
95
96///////////////////////////////////////////////////
97//      OS
98///////////////////////////////////////////////////
99
100#define USE_ALMOS 1
101//#define USE_GIET
102
103#ifdef USE_ALMOS
104#ifdef USE_GIET
105#error "Can't use Two different OS"
106#endif
107#endif
108
109#ifndef USE_ALMOS
110#ifndef USE_GIET
111#error "You need to specify one OS"
112#endif
113#endif
114
115///////////////////////////////////////////////////
116//               Parallelisation
117///////////////////////////////////////////////////
118#define USE_OPENMP 0
119
120#if USE_OPENMP
121#include <omp.h>
122#endif
123
124//  cluster index (computed from x,y coordinates)
125#define cluster(x,y)   (y + YMAX * x)
126
127///////////////////////////////////////////////////////////
128//          DSPIN parameters           
129///////////////////////////////////////////////////////////
130
131#define dspin_cmd_width      39
132#define dspin_rsp_width      32
133
134///////////////////////////////////////////////////////////
135//          VCI parameters           
136///////////////////////////////////////////////////////////
137
138#define vci_cell_width_int    4
139#define vci_cell_width_ext    8
140
141#ifdef USE_ALMOS
142#define vci_address_width     32
143#endif
144#ifdef USE_GIET
145#define vci_address_width     40
146#endif
147#define vci_plen_width        8
148#define vci_rerror_width      1
149#define vci_clen_width        1
150#define vci_rflag_width       1
151#define vci_srcid_width       14
152#define vci_pktid_width       4
153#define vci_trdid_width       4
154#define vci_wrplen_width      1
155
156////////////////////////////////////////////////////////////
157//    Main Hardware Parameters values         
158//////////////////////i/////////////////////////////////////
159
160#ifdef USE_ALMOS
161#include "almos/hard_config.h"
162#define PREFIX_OS "almos/"
163#endif
164#ifdef USE_GIET
165#include "giet_vm/hard_config.h"
166#define PREFIX_OS "giet_vm/"
167#endif
168
169////////////////////////////////////////////////////////////
170//    Secondary Hardware Parameters         
171//////////////////////i/////////////////////////////////////
172
173#define XMAX                  CLUSTER_X
174#define YMAX                  CLUSTER_Y
175
176#define XRAM_LATENCY          0
177
178#define MEMC_WAYS             16
179#define MEMC_SETS             256
180
181#define L1_IWAYS              4
182#define L1_ISETS              64
183
184#define L1_DWAYS              4
185#define L1_DSETS              64
186
187#ifdef USE_ALMOS
188#define FBUF_X_SIZE           512
189#define FBUF_Y_SIZE           512
190#endif
191#ifdef USE_GIET
192#define FBUF_X_SIZE           128
193#define FBUF_Y_SIZE           128
194#endif
195
196#ifdef USE_GIET
197#define BDEV_SECTOR_SIZE      512
198#define BDEV_IMAGE_NAME       PREFIX_OS"display/images.raw"
199#endif
200#ifdef USE_ALMOS
201#define BDEV_SECTOR_SIZE      4096
202#define BDEV_IMAGE_NAME       PREFIX_OS"hdd-img.bin"
203#endif
204
205#define NIC_RX_NAME           PREFIX_OS"nic/rx_packets.txt"
206#define NIC_TX_NAME           PREFIX_OS"nic/tx_packets.txt"
207#define NIC_TIMEOUT           10000
208
209#define NORTH                 0
210#define SOUTH                 1
211#define EAST                  2
212#define WEST                  3
213
214////////////////////////////////////////////////////////////
215//    Software to be loaded in ROM & RAM         
216//////////////////////i/////////////////////////////////////
217
218#ifdef USE_ALMOS
219#define soft_name       PREFIX_OS"bootloader.bin",\
220                        PREFIX_OS"kernel-soclib.bin@0xbfc10000:D",\
221                        PREFIX_OS"arch-info.bib@0xBFC08000:D"
222#endif
223#ifdef USE_GIET
224#define soft_pathname   PREFIX_OS"soft.elf"
225#endif
226
227////////////////////////////////////////////////////////////
228//     DEBUG Parameters default values         
229//////////////////////i/////////////////////////////////////
230
231#define MAX_FROZEN_CYCLES     100000
232
233/////////////////////////////////////////////////////////
234//    Physical segments definition
235/////////////////////////////////////////////////////////
236// There is 3 segments replicated in all clusters
237// and 5 specific segments in the "IO" cluster
238// (containing address 0xBF000000)
239/////////////////////////////////////////////////////////
240
241// specific segments in "IO" cluster : absolute physical address
242
243#define BROM_BASE       0x00BFC00000     
244#define BROM_SIZE       0x0000100000   // 1 Mbytes
245
246#define FBUF_BASE       0x00B2000000     
247#define FBUF_SIZE       (FBUF_X_SIZE * FBUF_Y_SIZE * 2)
248
249#define BDEV_BASE       0x00B3000000     
250#define BDEV_SIZE       0x0000001000   // 4 Kbytes
251
252#define MTTY_BASE       0x00B4000000     
253#define MTTY_SIZE       0x0000001000   // 4 Kbytes
254
255#define MNIC_BASE       0x00B5000000     
256#define MNIC_SIZE       0x0000080000   // 512 Kbytes (for 8 channels)
257
258#define CDMA_BASE       0x00B6000000     
259#define CDMA_SIZE       0x0000004000 * NB_CMA_CHANNELS
260
261// replicated segments : address is incremented by a cluster offset
262//     offset  = cluster(x,y) << (address_width-x_width-y_width);
263
264#define MEMC_BASE       0x0000000000     
265#define MEMC_SIZE       0x0010000000   // 256 Mbytes per cluster
266
267#ifdef USE_ALMOS
268   #define XICU_BASE    0x0030000000
269#endif
270#ifdef USE_GIET
271   #define XICU_BASE    0x00B0000000
272#endif
273#define XICU_SIZE       0x0000001000   // 4 Kbytes
274
275#ifdef USE_ALMOS
276   #define MDMA_BASE    0x0031000000
277#endif
278#ifdef USE_GIET
279   #define MDMA_BASE    0x00B1000000
280#endif
281#define MDMA_SIZE       0x0000001000 * NB_DMA_CHANNELS  // 4 Kbytes per channel 
282
283////////////////////////////////////////////////////////////////////
284//     TGTID definition in direct space
285// For all components:  global TGTID = global SRCID = cluster_index
286////////////////////////////////////////////////////////////////////
287
288#define MEMC_TGTID      0
289#define XICU_TGTID      1
290#define MDMA_TGTID      2
291#define MTTY_TGTID      3
292#define FBUF_TGTID      4
293#define BDEV_TGTID      5
294#define MNIC_TGTID      6
295#define BROM_TGTID      7
296#define CDMA_TGTID      8
297
298bool stop_called = false;
299
300/////////////////////////////////
301int _main(int argc, char *argv[])
302{
303   using namespace sc_core;
304   using namespace soclib::caba;
305   using namespace soclib::common;
306
307#ifdef USE_GIET
308   char     soft_name[256]   = soft_pathname;      // pathname to binary code
309#endif
310   uint64_t ncycles          = 0xFFFFFFFFFFFFFFFF; // simulated cycles
311   char     disk_name[256]   = BDEV_IMAGE_NAME;    // pathname to the disk image
312   char     nic_rx_name[256] = NIC_RX_NAME;        // pathname to the rx packets file
313   char     nic_tx_name[256] = NIC_TX_NAME;        // pathname to the tx packets file
314   ssize_t  threads_nr       = 1;                  // simulator's threads number
315   bool     debug_ok         = false;              // trace activated
316   size_t   debug_period     = 1;                  // trace period
317   size_t   debug_memc_id    = 0;                  // index of memc to be traced
318   size_t   debug_proc_id    = 0;                  // index of proc to be traced
319   uint32_t debug_from       = 0;                  // trace start cycle
320   uint32_t frozen_cycles    = MAX_FROZEN_CYCLES;  // monitoring frozen processor
321   size_t   cluster_io_id;                         // index of cluster containing IOs
322   struct   timeval t1,t2;
323   uint64_t ms1,ms2;
324
325   ////////////// command line arguments //////////////////////
326   if (argc > 1)
327   {
328      for (int n = 1; n < argc; n = n + 2)
329      {
330         if ((strcmp(argv[n], "-NCYCLES") == 0) && (n + 1 < argc))
331         {
332            ncycles = atoi(argv[n + 1]);
333         }
334         else if ((strcmp(argv[n], "-SOFT") == 0) && (n + 1 < argc))
335         {
336#ifdef USE_ALMOS
337            assert( 0 && "Can't define almos soft name" );
338#endif
339#ifdef USE_GIET
340            strcpy(soft_name, argv[n + 1]);
341#endif
342         }
343         else if ((strcmp(argv[n],"-DISK") == 0) && (n + 1 < argc))
344         {
345            strcpy(disk_name, argv[n + 1]);
346         }
347         else if ((strcmp(argv[n],"-DEBUG") == 0) && (n + 1 < argc))
348         {
349            debug_ok = true;
350            debug_from = atoi(argv[n + 1]);
351         }
352         else if ((strcmp(argv[n], "-MEMCID") == 0) && (n + 1 < argc))
353         {
354            debug_memc_id = atoi(argv[n + 1]);
355            assert((debug_memc_id < (XMAX * YMAX)) && 
356                   "debug_memc_id larger than XMAX * YMAX" );
357         }
358         else if ((strcmp(argv[n], "-PROCID") == 0) && (n + 1 < argc))
359         {
360            debug_proc_id = atoi(argv[n + 1]);
361            assert((debug_proc_id < (XMAX * YMAX * NB_PROCS_MAX)) && 
362                   "debug_proc_id larger than XMAX * YMAX * NB_PROCS");
363         }
364         else if ((strcmp(argv[n], "-THREADS") == 0) && ((n + 1) < argc))
365         {
366            threads_nr = atoi(argv[n + 1]);
367            threads_nr = (threads_nr < 1) ? 1 : threads_nr;
368         }
369         else if ((strcmp(argv[n], "-FROZEN") == 0) && (n + 1 < argc))
370         {
371            frozen_cycles = atoi(argv[n + 1]);
372         }
373         else if ((strcmp(argv[n], "-PERIOD") == 0) && (n + 1 < argc))
374         {
375            debug_period = atoi(argv[n + 1]);
376         }
377         else
378         {
379            std::cout << "   Arguments are (key,value) couples." << std::endl;
380            std::cout << "   The order is not important." << std::endl;
381            std::cout << "   Accepted arguments are :" << std::endl << std::endl;
382            std::cout << "     -SOFT pathname_for_embedded_soft" << std::endl;
383            std::cout << "     -DISK pathname_for_disk_image" << std::endl;
384            std::cout << "     -NCYCLES number_of_simulated_cycles" << std::endl;
385            std::cout << "     -DEBUG debug_start_cycle" << std::endl;
386            std::cout << "     -THREADS simulator's threads number" << std::endl;
387            std::cout << "     -FROZEN max_number_of_lines" << std::endl;
388            std::cout << "     -PERIOD number_of_cycles between trace" << std::endl;
389            std::cout << "     -MEMCID index_memc_to_be_traced" << std::endl;
390            std::cout << "     -PROCID index_proc_to_be_traced" << std::endl;
391            exit(0);
392         }
393      }
394   }
395
396    // checking hardware parameters
397    assert( ( (XMAX == 1) or (XMAX == 2) or (XMAX == 4) or
398              (XMAX == 8) or (XMAX == 16) ) and
399              "The XMAX parameter must be 1, 2, 4, 8 or 16" );
400
401    assert( ( (YMAX == 1) or (YMAX == 2) or (YMAX == 4) or
402              (YMAX == 8) or (YMAX == 16) ) and
403              "The YMAX parameter must be 1, 2, 4, 8 or 16" );
404
405    assert( ( (NB_PROCS_MAX == 1) or (NB_PROCS_MAX == 2) or
406              (NB_PROCS_MAX == 4) or (NB_PROCS_MAX == 8) ) and
407             "The NB_PROCS_MAX parameter must be 1, 2, 4 or 8" );
408
409    assert( (NB_DMA_CHANNELS < 9) and
410            "The NB_DMA_CHANNELS parameter must be smaller than 9" );
411
412    assert( (NB_TTY_CHANNELS < 15) and
413            "The NB_TTY_CHANNELS parameter must be smaller than 15" );
414
415    assert( (NB_NIC_CHANNELS < 9) and
416            "The NB_NIC_CHANNELS parameter must be smaller than 9" );
417
418#ifdef USE_GIET
419    assert( (vci_address_width == 40) and
420            "VCI address width with the GIET must be 40 bits" );
421#endif
422
423#ifdef USE_ALMOS
424    assert( (vci_address_width == 32) and
425            "VCI address width with ALMOS must be 32 bits" );
426#endif
427
428
429    std::cout << std::endl;
430    std::cout << " - XMAX             = " << XMAX << std::endl;
431    std::cout << " - YMAX             = " << YMAX << std::endl;
432    std::cout << " - NB_PROCS_MAX     = " << NB_PROCS_MAX <<  std::endl;
433    std::cout << " - NB_DMA_CHANNELS  = " << NB_DMA_CHANNELS <<  std::endl;
434    std::cout << " - NB_TTY_CHANNELS  = " << NB_TTY_CHANNELS <<  std::endl;
435    std::cout << " - NB_NIC_CHANNELS  = " << NB_NIC_CHANNELS <<  std::endl;
436    std::cout << " - MEMC_WAYS        = " << MEMC_WAYS << std::endl;
437    std::cout << " - MEMC_SETS        = " << MEMC_SETS << std::endl;
438    std::cout << " - RAM_LATENCY      = " << XRAM_LATENCY << std::endl;
439    std::cout << " - MAX_FROZEN       = " << frozen_cycles << std::endl;
440
441    std::cout << std::endl;
442    // Internal and External VCI parameters definition
443    typedef soclib::caba::VciParams<vci_cell_width_int,
444                                    vci_plen_width,
445                                    vci_address_width,
446                                    vci_rerror_width,
447                                    vci_clen_width,
448                                    vci_rflag_width,
449                                    vci_srcid_width,
450                                    vci_pktid_width,
451                                    vci_trdid_width,
452                                    vci_wrplen_width> vci_param_int;
453
454    typedef soclib::caba::VciParams<vci_cell_width_ext,
455                                    vci_plen_width,
456                                    vci_address_width,
457                                    vci_rerror_width,
458                                    vci_clen_width,
459                                    vci_rflag_width,
460                                    vci_srcid_width,
461                                    vci_pktid_width,
462                                    vci_trdid_width,
463                                    vci_wrplen_width> vci_param_ext;
464
465#if USE_OPENMP
466   omp_set_dynamic(false);
467   omp_set_num_threads(threads_nr);
468   std::cerr << "Built with openmp version " << _OPENMP << std::endl;
469#endif
470
471   // Define parameters depending on mesh size
472   size_t   x_width;
473   size_t   y_width;
474
475   if      (XMAX == 1) x_width = 0;
476   else if (XMAX == 2) x_width = 1;
477   else if (XMAX <= 4) x_width = 2;
478   else if (XMAX <= 8) x_width = 3;
479   else                x_width = 4;
480
481   if      (YMAX == 1) y_width = 0;
482   else if (YMAX == 2) y_width = 1;
483   else if (YMAX <= 4) y_width = 2;
484   else if (YMAX <= 8) y_width = 3;
485   else                y_width = 4;
486
487
488#ifdef USE_ALMOS
489   cluster_io_id = 0xbfc00000 >> (vci_address_width - x_width - y_width); // index of cluster containing IOs
490#else
491   cluster_io_id = 0;
492#endif
493
494   /////////////////////
495   //  Mapping Tables
496   /////////////////////
497
498   // internal network
499   MappingTable maptabd(vci_address_width, 
500                        IntTab(x_width + y_width, 16 - x_width - y_width), 
501                        IntTab(x_width + y_width, vci_srcid_width - x_width - y_width), 
502                        0x00FF000000);
503
504   for (size_t x = 0; x < XMAX; x++)
505   {
506      for (size_t y = 0; y < YMAX; y++)
507      {
508         sc_uint<vci_address_width> offset;
509         offset = (sc_uint<vci_address_width>)cluster(x,y) 
510                   << (vci_address_width-x_width-y_width);
511
512         std::ostringstream    sh;
513         sh << "seg_memc_" << x << "_" << y;
514         maptabd.add(Segment(sh.str(), MEMC_BASE+offset, MEMC_SIZE, 
515                             IntTab(cluster(x,y),MEMC_TGTID), true));
516
517         std::ostringstream    si;
518         si << "seg_xicu_" << x << "_" << y;
519         maptabd.add(Segment(si.str(), XICU_BASE+offset, XICU_SIZE, 
520                             IntTab(cluster(x,y),XICU_TGTID), false));
521
522         std::ostringstream    sd;
523         sd << "seg_mdma_" << x << "_" << y;
524         maptabd.add(Segment(sd.str(), MDMA_BASE+offset, MDMA_SIZE, 
525                             IntTab(cluster(x,y),MDMA_TGTID), false));
526
527         if ( cluster(x,y) == cluster_io_id )
528         {
529            maptabd.add(Segment("seg_mtty", MTTY_BASE, MTTY_SIZE, 
530                        IntTab(cluster(x,y),MTTY_TGTID), false));
531            maptabd.add(Segment("seg_fbuf", FBUF_BASE, FBUF_SIZE, 
532                        IntTab(cluster(x,y),FBUF_TGTID), false));
533            maptabd.add(Segment("seg_bdev", BDEV_BASE, BDEV_SIZE, 
534                        IntTab(cluster(x,y),BDEV_TGTID), false));
535            maptabd.add(Segment("seg_mnic", MNIC_BASE, MNIC_SIZE, 
536                        IntTab(cluster(x,y),MNIC_TGTID), false));
537            maptabd.add(Segment("seg_cdma", CDMA_BASE, CDMA_SIZE, 
538                        IntTab(cluster(x,y),CDMA_TGTID), false));
539            maptabd.add(Segment("seg_brom", BROM_BASE, BROM_SIZE, 
540                        IntTab(cluster(x,y),BROM_TGTID), true));
541         }
542      }
543   }
544   std::cout << maptabd << std::endl;
545
546   // external network
547   MappingTable maptabx(vci_address_width, 
548                        IntTab(x_width+y_width), 
549                        IntTab(x_width+y_width), 
550                        0xFFFF000000ULL);
551
552   for (size_t x = 0; x < XMAX; x++)
553   {
554      for (size_t y = 0; y < YMAX ; y++)
555      { 
556
557         sc_uint<vci_address_width> offset;
558         offset = (sc_uint<vci_address_width>)cluster(x,y) 
559                   << (vci_address_width-x_width-y_width);
560
561         std::ostringstream sh;
562         sh << "x_seg_memc_" << x << "_" << y;
563
564         maptabx.add(Segment(sh.str(), MEMC_BASE+offset, 
565                     MEMC_SIZE, IntTab(cluster(x,y)), false));
566      }
567   }
568   std::cout << maptabx << std::endl;
569
570   ////////////////////
571   // Signals
572   ///////////////////
573
574   sc_clock           signal_clk("clk");
575   sc_signal<bool>    signal_resetn("resetn");
576
577   // Horizontal inter-clusters DSPIN signals
578   DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_inc =
579      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_inc", XMAX-1, YMAX, 3);
580   DspinSignals<dspin_cmd_width>*** signal_dspin_h_cmd_dec =
581      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_h_cmd_dec", XMAX-1, YMAX, 3);
582   DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_inc =
583      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_inc", XMAX-1, YMAX, 2);
584   DspinSignals<dspin_rsp_width>*** signal_dspin_h_rsp_dec =
585      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_h_rsp_dec", XMAX-1, YMAX, 2);
586
587   // Vertical inter-clusters DSPIN signals
588   DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_inc =
589      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_inc", XMAX, YMAX-1, 3);
590   DspinSignals<dspin_cmd_width>*** signal_dspin_v_cmd_dec =
591      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_v_cmd_dec", XMAX, YMAX-1, 3);
592   DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_inc =
593      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_inc", XMAX, YMAX-1, 2);
594   DspinSignals<dspin_rsp_width>*** signal_dspin_v_rsp_dec =
595      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_v_rsp_dec", XMAX, YMAX-1, 2);
596
597   // Mesh boundaries DSPIN signals
598   DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_in =
599      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_in" , XMAX, YMAX, 4, 3);
600   DspinSignals<dspin_cmd_width>**** signal_dspin_false_cmd_out =
601      alloc_elems<DspinSignals<dspin_cmd_width> >("signal_dspin_false_cmd_out", XMAX, YMAX, 4, 3);
602   DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_in =
603      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_in" , XMAX, YMAX, 4, 2);
604   DspinSignals<dspin_rsp_width>**** signal_dspin_false_rsp_out =
605      alloc_elems<DspinSignals<dspin_rsp_width> >("signal_dspin_false_rsp_out", XMAX, YMAX, 4, 2);
606
607
608   ////////////////////////////
609   //      Loader   
610   ////////////////////////////
611
612   soclib::common::Loader loader(soft_name);
613
614   typedef soclib::common::GdbServer<soclib::common::Mips32ElIss> proc_iss;
615   proc_iss::set_loader(loader);
616
617   ////////////////////////////
618   // Clusters construction
619   ////////////////////////////
620
621   TsarXbarCluster<dspin_cmd_width,
622                   dspin_rsp_width,
623                   vci_param_int,
624                   vci_param_ext>*          clusters[XMAX][YMAX];
625
626#if USE_OPENMP
627#pragma omp parallel
628    {
629#pragma omp for
630#endif
631        for (size_t i = 0; i  < (XMAX * YMAX); i++)
632        {
633            size_t x = i / YMAX;
634            size_t y = i % YMAX;
635
636#if USE_OPENMP
637#pragma omp critical
638            {
639#endif
640            std::cout << std::endl;
641            std::cout << "Cluster_" << x << "_" << y << std::endl;
642            std::cout << std::endl;
643
644            std::ostringstream sc;
645            sc << "cluster_" << x << "_" << y;
646            clusters[x][y] = new TsarXbarCluster<dspin_cmd_width,
647                                                 dspin_rsp_width,
648                                                 vci_param_int,
649                                                 vci_param_ext>
650            (
651                sc.str().c_str(),
652                NB_PROCS_MAX,
653                NB_TTY_CHANNELS, 
654                NB_DMA_CHANNELS, 
655                x,
656                y,
657                cluster(x,y),
658                maptabd,
659                maptabx,
660                x_width,
661                y_width,
662                vci_srcid_width - x_width - y_width,   // l_id width,
663                MEMC_TGTID,
664                XICU_TGTID,
665                MDMA_TGTID,
666                FBUF_TGTID,
667                MTTY_TGTID,
668                BROM_TGTID,
669                MNIC_TGTID,
670                CDMA_TGTID,
671                BDEV_TGTID,
672                MEMC_WAYS,
673                MEMC_SETS,
674                L1_IWAYS,
675                L1_ISETS,
676                L1_DWAYS,
677                L1_DSETS,
678                XRAM_LATENCY,
679                (cluster(x,y) == cluster_io_id),
680                FBUF_X_SIZE,
681                FBUF_Y_SIZE,
682                disk_name,
683                BDEV_SECTOR_SIZE,
684                NB_NIC_CHANNELS,
685                nic_rx_name,
686                nic_tx_name,
687                NIC_TIMEOUT,
688                NB_CMA_CHANNELS,
689                loader,
690                frozen_cycles,
691                debug_from   ,
692                debug_ok and (cluster(x,y) == debug_memc_id),
693                debug_ok and (cluster(x,y) == debug_proc_id) 
694            );
695
696#if USE_OPENMP
697            } // end critical
698#endif
699        } // end for
700#if USE_OPENMP
701    }
702#endif
703
704   ///////////////////////////////////////////////////////////////
705   //     Net-list
706   ///////////////////////////////////////////////////////////////
707
708   // Clock & RESET
709   for (size_t x = 0; x < (XMAX); x++){
710      for (size_t y = 0; y < YMAX; y++){
711         clusters[x][y]->p_clk                         (signal_clk);
712         clusters[x][y]->p_resetn                      (signal_resetn);
713      }
714   }
715
716   // Inter Clusters horizontal connections
717   if (XMAX > 1){
718      for (size_t x = 0; x < (XMAX-1); x++){
719         for (size_t y = 0; y < YMAX; y++){
720            for (size_t k = 0; k < 3; k++){
721               clusters[x][y]->p_cmd_out[EAST][k]      (signal_dspin_h_cmd_inc[x][y][k]);
722               clusters[x+1][y]->p_cmd_in[WEST][k]     (signal_dspin_h_cmd_inc[x][y][k]);
723               clusters[x][y]->p_cmd_in[EAST][k]       (signal_dspin_h_cmd_dec[x][y][k]);
724               clusters[x+1][y]->p_cmd_out[WEST][k]    (signal_dspin_h_cmd_dec[x][y][k]);
725            }
726
727            for (size_t k = 0; k < 2; k++){
728               clusters[x][y]->p_rsp_out[EAST][k]      (signal_dspin_h_rsp_inc[x][y][k]);
729               clusters[x+1][y]->p_rsp_in[WEST][k]     (signal_dspin_h_rsp_inc[x][y][k]);
730               clusters[x][y]->p_rsp_in[EAST][k]       (signal_dspin_h_rsp_dec[x][y][k]);
731               clusters[x+1][y]->p_rsp_out[WEST][k]    (signal_dspin_h_rsp_dec[x][y][k]);
732            }
733         }
734      }
735   }
736   std::cout << std::endl << "Horizontal connections established" << std::endl;   
737
738   // Inter Clusters vertical connections
739   if (YMAX > 1) {
740      for (size_t y = 0; y < (YMAX-1); y++){
741         for (size_t x = 0; x < XMAX; x++){
742            for (size_t k = 0; k < 3; k++){
743               clusters[x][y]->p_cmd_out[NORTH][k]     (signal_dspin_v_cmd_inc[x][y][k]);
744               clusters[x][y+1]->p_cmd_in[SOUTH][k]    (signal_dspin_v_cmd_inc[x][y][k]);
745               clusters[x][y]->p_cmd_in[NORTH][k]      (signal_dspin_v_cmd_dec[x][y][k]);
746               clusters[x][y+1]->p_cmd_out[SOUTH][k]   (signal_dspin_v_cmd_dec[x][y][k]);
747            }
748
749            for (size_t k = 0; k < 2; k++){
750               clusters[x][y]->p_rsp_out[NORTH][k]     (signal_dspin_v_rsp_inc[x][y][k]);
751               clusters[x][y+1]->p_rsp_in[SOUTH][k]    (signal_dspin_v_rsp_inc[x][y][k]);
752               clusters[x][y]->p_rsp_in[NORTH][k]      (signal_dspin_v_rsp_dec[x][y][k]);
753               clusters[x][y+1]->p_rsp_out[SOUTH][k]   (signal_dspin_v_rsp_dec[x][y][k]);
754            }
755         }
756      }
757   }
758   std::cout << "Vertical connections established" << std::endl;
759
760   // East & West boundary cluster connections
761   for (size_t y = 0; y < YMAX; y++)
762   {
763      for (size_t k = 0; k < 3; k++)
764      {
765         clusters[0][y]->p_cmd_in[WEST][k]        (signal_dspin_false_cmd_in[0][y][WEST][k]);
766         clusters[0][y]->p_cmd_out[WEST][k]       (signal_dspin_false_cmd_out[0][y][WEST][k]);
767         clusters[XMAX-1][y]->p_cmd_in[EAST][k]   (signal_dspin_false_cmd_in[XMAX-1][y][EAST][k]);
768         clusters[XMAX-1][y]->p_cmd_out[EAST][k]  (signal_dspin_false_cmd_out[XMAX-1][y][EAST][k]);
769      }
770
771      for (size_t k = 0; k < 2; k++)
772      {
773         clusters[0][y]->p_rsp_in[WEST][k]        (signal_dspin_false_rsp_in[0][y][WEST][k]);
774         clusters[0][y]->p_rsp_out[WEST][k]       (signal_dspin_false_rsp_out[0][y][WEST][k]);
775         clusters[XMAX-1][y]->p_rsp_in[EAST][k]   (signal_dspin_false_rsp_in[XMAX-1][y][EAST][k]);
776         clusters[XMAX-1][y]->p_rsp_out[EAST][k]  (signal_dspin_false_rsp_out[XMAX-1][y][EAST][k]);
777      }
778   }
779
780   // North & South boundary clusters connections
781   for (size_t x = 0; x < XMAX; x++)
782   {
783      for (size_t k = 0; k < 3; k++)
784      {
785         clusters[x][0]->p_cmd_in[SOUTH][k]       (signal_dspin_false_cmd_in[x][0][SOUTH][k]);
786         clusters[x][0]->p_cmd_out[SOUTH][k]      (signal_dspin_false_cmd_out[x][0][SOUTH][k]);
787         clusters[x][YMAX-1]->p_cmd_in[NORTH][k]  (signal_dspin_false_cmd_in[x][YMAX-1][NORTH][k]);
788         clusters[x][YMAX-1]->p_cmd_out[NORTH][k] (signal_dspin_false_cmd_out[x][YMAX-1][NORTH][k]);
789      }
790
791      for (size_t k = 0; k < 2; k++)
792      {
793         clusters[x][0]->p_rsp_in[SOUTH][k]       (signal_dspin_false_rsp_in[x][0][SOUTH][k]);
794         clusters[x][0]->p_rsp_out[SOUTH][k]      (signal_dspin_false_rsp_out[x][0][SOUTH][k]);
795         clusters[x][YMAX-1]->p_rsp_in[NORTH][k]  (signal_dspin_false_rsp_in[x][YMAX-1][NORTH][k]);
796         clusters[x][YMAX-1]->p_rsp_out[NORTH][k] (signal_dspin_false_rsp_out[x][YMAX-1][NORTH][k]);
797      }
798   }
799   std::cout << "North, South, West, East connections established" << std::endl;
800   std::cout << std::endl;
801
802
803   ////////////////////////////////////////////////////////
804   //   Simulation
805   ///////////////////////////////////////////////////////
806
807   sc_start(sc_core::sc_time(0, SC_NS));
808   signal_resetn = false;
809
810   // network boundaries signals
811   for (size_t x = 0; x < XMAX ; x++){
812      for (size_t y = 0; y < YMAX ; y++){
813         for (size_t a = 0; a < 4; a++){
814            for (size_t k = 0; k < 3; k++){
815               signal_dspin_false_cmd_in [x][y][a][k].write = false;
816               signal_dspin_false_cmd_in [x][y][a][k].read  = true;
817               signal_dspin_false_cmd_out[x][y][a][k].write = false;
818               signal_dspin_false_cmd_out[x][y][a][k].read  = true;
819            }
820
821            for (size_t k = 0; k < 2; k++){
822               signal_dspin_false_rsp_in [x][y][a][k].write = false;
823               signal_dspin_false_rsp_in [x][y][a][k].read  = true;
824               signal_dspin_false_rsp_out[x][y][a][k].write = false;
825               signal_dspin_false_rsp_out[x][y][a][k].read  = true;
826            }
827         }
828      }
829   }
830
831   sc_start(sc_core::sc_time(1, SC_NS));
832   signal_resetn = true;
833
834   if (gettimeofday(&t1, NULL) != 0) 
835   {
836      perror("gettimeofday");
837      return EXIT_FAILURE;
838   }
839
840   for (uint64_t n = 1; n < ncycles && !stop_called; n++)
841   {
842      // Monitor a specific address for L1 & L2 caches
843      //clusters[0][0]->proc[0]->cache_monitor(0x800002c000ULL);
844      //clusters[1][0]->memc->copies_monitor(0x800002C000ULL);
845
846      if( (n % 5000000) == 0)
847      {
848
849         if (gettimeofday(&t2, NULL) != 0) 
850         {
851            perror("gettimeofday");
852            return EXIT_FAILURE;
853         }
854
855         ms1 = (uint64_t) t1.tv_sec * 1000ULL + (uint64_t) t1.tv_usec / 1000;
856         ms2 = (uint64_t) t2.tv_sec * 1000ULL + (uint64_t) t2.tv_usec / 1000;
857         std::cerr << "platform clock frequency " << (double) 5000000 / (double) (ms2 - ms1) << "Khz" << std::endl;
858
859         if (gettimeofday(&t1, NULL) != 0) 
860         {
861            perror("gettimeofday");
862            return EXIT_FAILURE;
863         }
864      }
865
866      if (debug_ok and (n > debug_from) and (n % debug_period == 0))
867      {
868         std::cout << "****************** cycle " << std::dec << n ;
869         std::cout << " ************************************************" << std::endl;
870
871        // trace proc[debug_proc_id]
872        size_t l = debug_proc_id % NB_PROCS_MAX ;
873        size_t y = (debug_proc_id / NB_PROCS_MAX) % YMAX ;
874        size_t x = debug_proc_id / (YMAX * NB_PROCS_MAX) ;
875
876        std::ostringstream proc_signame;
877        proc_signame << "[SIG]PROC_" << x << "_" << y << "_" << l ;
878        std::ostringstream p2m_signame;
879        p2m_signame << "[SIG]PROC_" << x << "_" << y << "_" << l << " P2M" ;
880        std::ostringstream m2p_signame;
881        m2p_signame << "[SIG]PROC_" << x << "_" << y << "_" << l << " M2P" ;
882        std::ostringstream p_cmd_signame;
883        p_cmd_signame << "[SIG]PROC_" << x << "_" << y << "_" << l << " CMD" ;
884        std::ostringstream p_rsp_signame;
885        p_rsp_signame << "[SIG]PROC_" << x << "_" << y << "_" << l << " RSP" ;
886
887        clusters[x][y]->proc[l]->print_trace();
888        clusters[x][y]->wi_proc[l]->print_trace();
889        clusters[x][y]->signal_vci_ini_proc[l].print_trace(proc_signame.str());
890        clusters[x][y]->signal_dspin_p2m_proc[l].print_trace(p2m_signame.str());
891        clusters[x][y]->signal_dspin_m2p_proc[l].print_trace(m2p_signame.str());
892        clusters[x][y]->signal_dspin_cmd_proc_i[l].print_trace(p_cmd_signame.str());
893        clusters[x][y]->signal_dspin_rsp_proc_i[l].print_trace(p_rsp_signame.str());
894
895        clusters[x][y]->xbar_rsp_d->print_trace();
896        clusters[x][y]->xbar_cmd_d->print_trace();
897        clusters[x][y]->signal_dspin_cmd_l2g_d.print_trace("[SIG]L2G CMD");
898        clusters[x][y]->signal_dspin_cmd_g2l_d.print_trace("[SIG]G2L CMD");
899        clusters[x][y]->signal_dspin_rsp_l2g_d.print_trace("[SIG]L2G RSP");
900        clusters[x][y]->signal_dspin_rsp_g2l_d.print_trace("[SIG]G2L RSP");
901
902        // trace memc[debug_memc_id]
903        x = debug_memc_id / YMAX;
904        y = debug_memc_id % YMAX;
905
906        std::ostringstream smemc;
907        smemc << "[SIG]MEMC_" << x << "_" << y;
908        std::ostringstream sxram;
909        sxram << "[SIG]XRAM_" << x << "_" << y;
910        std::ostringstream sm2p;
911        sm2p << "[SIG]MEMC_" << x << "_" << y << " M2P" ;
912        std::ostringstream sp2m;
913        sp2m << "[SIG]MEMC_" << x << "_" << y << " P2M" ;
914        std::ostringstream m_cmd_signame;
915        m_cmd_signame << "[SIG]MEMC_" << x << "_" << y <<  " CMD" ;
916        std::ostringstream m_rsp_signame;
917        m_rsp_signame << "[SIG]MEMC_" << x << "_" << y <<  " RSP" ;
918
919        clusters[x][y]->memc->print_trace();
920        clusters[x][y]->wt_memc->print_trace();
921        clusters[x][y]->signal_vci_tgt_memc.print_trace(smemc.str());
922        clusters[x][y]->signal_vci_xram.print_trace(sxram.str());
923        clusters[x][y]->signal_dspin_p2m_memc.print_trace(sp2m.str());
924        clusters[x][y]->signal_dspin_m2p_memc.print_trace(sm2p.str());
925        clusters[x][y]->signal_dspin_cmd_memc_t.print_trace(m_cmd_signame.str());
926        clusters[x][y]->signal_dspin_rsp_memc_t.print_trace(m_rsp_signame.str());
927       
928        // trace replicated peripherals
929//        clusters[1][1]->mdma->print_trace();
930//        clusters[1][1]->signal_vci_tgt_mdma.print_trace("[SIG]MDMA_TGT_1_1");
931//        clusters[1][1]->signal_vci_ini_mdma.print_trace("[SIG]MDMA_INI_1_1");
932       
933
934        // trace external peripherals
935        size_t io_x   = cluster_io_id / YMAX;
936        size_t io_y   = cluster_io_id % YMAX;
937       
938        clusters[io_x][io_y]->brom->print_trace();
939        clusters[io_x][io_y]->wt_brom->print_trace();
940        clusters[io_x][io_y]->signal_vci_tgt_brom.print_trace("[SIG]BROM");
941        clusters[io_x][io_y]->signal_dspin_cmd_brom_t.print_trace("[SIG]BROM CMD");
942        clusters[io_x][io_y]->signal_dspin_rsp_brom_t.print_trace("[SIG]BROM RSP");
943
944//        clusters[io_x][io_y]->bdev->print_trace();
945//        clusters[io_x][io_y]->signal_vci_tgt_bdev.print_trace("[SIG]BDEV_TGT");
946//        clusters[io_x][io_y]->signal_vci_ini_bdev.print_trace("[SIG]BDEV_INI");
947      }
948
949      sc_start(sc_core::sc_time(1, SC_NS));
950   }
951
952   
953   for (size_t i = 0; i  < (XMAX * YMAX); i++)
954   {
955      size_t x = i / YMAX;
956      size_t y = i % YMAX;
957      delete clusters[x][y];
958   }
959
960   return EXIT_SUCCESS;
961}
962
963
964void handler(int dummy = 0) {
965   stop_called = true;
966   sc_stop();
967}
968
969
970int sc_main (int argc, char *argv[])
971{
972   signal(SIGINT, handler);
973
974   try {
975      return _main(argc, argv);
976   } catch (std::exception &e) {
977      std::cout << e.what() << std::endl;
978   } catch (...) {
979      std::cout << "Unknown exception occured" << std::endl;
980      throw;
981   }
982   return 1;
983}
984
985
986// Local Variables:
987// tab-width: 3
988// c-basic-offset: 3
989// c-file-offsets:((innamespace . 0)(inline-open . 0))
990// indent-tabs-mode: nil
991// End:
992
993// vim: filetype=cpp:expandtab:shiftwidth=3:tabstop=3:softtabstop=3
Note: See TracBrowser for help on using the repository browser.