Changeset 855


Ignore:
Timestamp:
Oct 21, 2014, 5:52:59 PM (8 years ago)
Author:
cfuguet
Message:

reconf: introducing a -FAULTY_ROUTER argument in tsar_generic_iob platform

  • This argument passes the XY id of the router to disable before the simulation.
  • Using the reconf:dspin_router instead of the soclib:dspin_router component in tsar_iob_cluster.
Location:
branches/reconfiguration/platforms/tsar_generic_iob
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/reconfiguration/platforms/tsar_generic_iob/scripts/onerun.py

    r847 r855  
    3939    '--batch-mode', '-b', dest='batchmode', action='store_true',
    4040    help='run simulation in batch mode: no interactive TTY or FrameBuffer')
     41
     42parser.add_argument(
     43    '--faulty-router', '-f', dest='faultyrouter', default=-1,
     44    help='ID (X,Y) of faulty router')
     45
     46parser.add_argument(
     47    '--debug', '-g', dest='debug', nargs=4,
     48    help='needs four arguments: from, to, procid, memcid')
    4149
    4250args = parser.parse_args()
     
    117125command.extend(["-DISK", "/dev/null"])
    118126command.extend(["-THREADS", str(ompthreads)])
    119 command.extend(["-NCYCLES", "1000000"])
     127
     128if args.faultyrouter != -1:
     129    command.extend(["-FAULTY_ROUTER", str(args.faultyrouter)])
     130
     131if args.debug != None:
     132    command.extend(["-DEBUG", str(args.debug[0])]);
     133    command.extend(["-NCYCLES", str(args.debug[1])]);
     134    command.extend(["-PROCID", str(args.debug[2])]);
     135    command.extend(["-MEMCID", str(args.debug[3])]);
     136else:
     137    command.extend(["-NCYCLES", "1000000"])
     138
    120139subprocess.call(command, stdout=logfile, stderr=logfile)
    121140
  • branches/reconfiguration/platforms/tsar_generic_iob/top.cpp

    r806 r855  
    5555// - IRQ_IN[4] : DMA channel 3
    5656//
    57 // All clusters are identical, but cluster(0,0) and cluster(X_SIZE-1,Y_SIZE-1)
     57// All clusters are identical, but cluster(0, 0) and cluster(X_SIZE-1, Y_SIZE-1)
    5858// contain an extra IO bridge component. These IOB0 & IOB1 components are
    5959// connected to the three networks (INT, RAM, IOX).
     
    213213#define WEST                  3
    214214
    215 #define cluster(x,y)   ((y) + ((x) << 4))
     215#define cluster(x, y)   ((y) + ((x) << Y_WIDTH))
    216216
    217217////////////////////////////////////////////////////////////
     
    234234// in the hard_config.h file. For replicated segments, the
    235235// base address is incremented by a cluster offset:
    236 // offset  = cluster(x,y) << (address_width-X_WIDTH-Y_WIDTH);
     236// offset  = cluster(x, y) << (address_width-X_WIDTH-Y_WIDTH);
    237237
    238238////////////////////////////////////////////////////////////////////////
     
    318318
    319319
    320    char     soft_name[256]   = BOOT_SOFT_NAME;             // pathname: binary code
    321    size_t   ncycles          = UINT_MAX;                   // simulated cycles
    322    char     disk_name[256]   = BDEV_IMAGE_NAME;            // pathname: disk image
    323    char     nic_rx_name[256] = NIC_RX_NAME;                // pathname: rx packets file
    324    char     nic_tx_name[256] = NIC_TX_NAME;                // pathname: tx packets file
    325    ssize_t  threads_nr       = 1;                          // simulator's threads number
    326    bool     debug_ok         = false;                      // trace activated
    327    size_t   debug_period     = 1;                          // trace period
    328    size_t   debug_memc_id    = 0xFFFFFFFF;                 // index of traced memc
    329    size_t   debug_proc_id    = 0xFFFFFFFF;                 // index of traced proc
    330    size_t   debug_xram_id    = 0xFFFFFFFF;                 // index of traced xram
    331    bool     debug_iob        = false;                      // trace iob0 & iob1 when true
    332    uint32_t debug_from       = 0;                          // trace start cycle
    333    uint32_t frozen_cycles    = MAX_FROZEN_CYCLES;          // monitoring frozen processor
    334    size_t   cluster_iob0     = cluster(0,0);               // cluster containing IOB0
    335    size_t   cluster_iob1     = cluster(X_SIZE-1,Y_SIZE-1); // cluster containing IOB1
     320   char     soft_name[256]   = BOOT_SOFT_NAME;              // pathname: binary code
     321   size_t   ncycles          = UINT_MAX;                    // simulated cycles
     322   char     disk_name[256]   = BDEV_IMAGE_NAME;             // pathname: disk image
     323   char     nic_rx_name[256] = NIC_RX_NAME;                 // pathname: rx packets file
     324   char     nic_tx_name[256] = NIC_TX_NAME;                 // pathname: tx packets file
     325   ssize_t  threads_nr       = 1;                           // simulator's threads number
     326   size_t   faulty_router_id = 0xFFFFFFFF;                  // faulty router coordinates
     327   bool     debug_ok         = false;                       // trace activated
     328   size_t   debug_period     = 1;                           // trace period
     329   size_t   debug_memc_id    = 0xFFFFFFFF;                  // index of traced memc
     330   size_t   debug_proc_id    = 0xFFFFFFFF;                  // index of traced proc
     331   size_t   debug_xram_id    = 0xFFFFFFFF;                  // index of traced xram
     332   bool     debug_iob        = false;                       // trace iob0 & iob1 when true
     333   uint32_t debug_from       = 0;                           // trace start cycle
     334   uint32_t frozen_cycles    = MAX_FROZEN_CYCLES;           // monitoring frozen processor
     335   size_t   cluster_iob0     = cluster(0, 0);               // cluster containing IOB0
     336   size_t   cluster_iob1     = cluster(X_SIZE-1, Y_SIZE-1); // cluster containing IOB1
    336337
    337338   assert( (X_WIDTH == 4) and (Y_WIDTH == 4) and
     
    343344      for (int n = 1; n < argc; n = n + 2)
    344345      {
    345          if ((strcmp(argv[n],"-NCYCLES") == 0) && (n+1<argc))
     346         if ((strcmp(argv[n], "-NCYCLES") == 0) && (n+1<argc))
    346347         {
    347348            ncycles = strtol(argv[n+1], NULL, 0);
    348349         }
    349          else if ((strcmp(argv[n],"-SOFT") == 0) && (n+1<argc) )
     350         else if ((strcmp(argv[n], "-SOFT") == 0) && (n+1<argc) )
    350351         {
    351352            strcpy(soft_name, argv[n+1]);
    352353         }
    353          else if ((strcmp(argv[n],"-DEBUG") == 0) && (n+1<argc) )
     354         else if ((strcmp(argv[n], "-DEBUG") == 0) && (n+1<argc) )
    354355         {
    355356            debug_ok = true;
    356357            debug_from = strtol(argv[n+1], NULL, 0);
    357358         }
    358          else if ((strcmp(argv[n],"-DISK") == 0) && (n+1<argc) )
     359         else if ((strcmp(argv[n], "-DISK") == 0) && (n+1<argc) )
    359360         {
    360361            strcpy(disk_name, argv[n+1]);
    361362         }
    362          else if ((strcmp(argv[n],"-MEMCID") == 0) && (n+1<argc) )
     363         else if ((strcmp(argv[n], "-MEMCID") == 0) && (n+1<argc) )
    363364         {
    364365            debug_memc_id = strtol(argv[n+1], NULL, 0);
    365             size_t x = debug_memc_id >> 4;
    366             size_t y = debug_memc_id & 0xF;
     366            size_t x = debug_memc_id >> Y_WIDTH;
     367            size_t y = debug_memc_id & ((1 << Y_WIDTH) - 1);
    367368            if( (x>=X_SIZE) || (y>=Y_SIZE) )
    368369            {
     
    371372            }
    372373         }
    373          else if ((strcmp(argv[n],"-XRAMID") == 0) && (n+1<argc) )
     374         else if ((strcmp(argv[n], "-XRAMID") == 0) && (n+1<argc) )
    374375         {
    375376            debug_xram_id = strtol(argv[n+1], NULL, 0);
    376             size_t x = debug_xram_id >> 4;
    377             size_t y = debug_xram_id & 0xF;
     377            size_t x = debug_xram_id >> Y_WIDTH;
     378            size_t y = debug_xram_id & ((1 << Y_WIDTH) - 1);
    378379            if( (x>=X_SIZE) || (y>=Y_SIZE) )
    379380            {
     
    382383            }
    383384         }
    384          else if ((strcmp(argv[n],"-IOB") == 0) && (n+1<argc) )
     385         else if ((strcmp(argv[n], "-IOB") == 0) && (n+1<argc) )
    385386         {
    386387            debug_iob = strtol(argv[n+1], NULL, 0);
    387388         }
    388          else if ((strcmp(argv[n],"-PROCID") == 0) && (n+1<argc) )
     389         else if ((strcmp(argv[n], "-PROCID") == 0) && (n+1<argc) )
    389390         {
    390391            debug_proc_id     = strtol(argv[n+1], NULL, 0);
    391             size_t cluster_xy = debug_proc_id / NB_PROCS_MAX ;
    392             size_t x          = cluster_xy >> 4;
    393             size_t y          = cluster_xy & 0xF;
     392            size_t cluster_xy = debug_proc_id >> P_WIDTH;
     393            size_t x          = cluster_xy >> Y_WIDTH;
     394            size_t y          = cluster_xy & ((1 << Y_WIDTH) - 1);
    394395            if( (x>=X_SIZE) || (y>=Y_SIZE) )
    395396            {
     
    411412            debug_period = strtol(argv[n+1], NULL, 0);
    412413         }
     414         else if ((strcmp(argv[n], "-FAULTY_ROUTER") == 0) && (n+1 < argc) )
     415         {
     416            faulty_router_id = strtol(argv[n+1], NULL, 0);
     417            size_t x = faulty_router_id >> Y_WIDTH;
     418            size_t y = faulty_router_id & ((1 << Y_WIDTH) - 1);
     419            if( (x>=X_SIZE) || (y>=Y_SIZE) )
     420            {
     421                std::cout << "FAULTY_ROUTER parameter doesn't fit X_SIZE/Y_SIZE" << std::endl;
     422                exit(0);
     423            }
     424         }
    413425         else
    414426         {
    415             std::cout << "   Arguments are (key,value) couples." << std::endl;
     427            std::cout << "   Arguments are (key, value) couples." << std::endl;
    416428            std::cout << "   The order is not important." << std::endl;
    417429            std::cout << "   Accepted arguments are :" << std::endl << std::endl;
     
    522534      for (size_t y = 0; y < Y_SIZE; y++)
    523535      {
    524          uint64_t offset = ((uint64_t)cluster(x,y))
     536         uint64_t offset = ((uint64_t)cluster(x, y))
    525537                              << (vci_address_width-X_WIDTH-Y_WIDTH);
    526538         bool config    = true;
     
    532544         smemc_conf << "int_seg_memc_conf_" << x << "_" << y;
    533545         maptab_int.add(Segment(smemc_conf.str(), SEG_MMC_BASE+offset, SEG_MMC_SIZE,
    534                      IntTab(cluster(x,y), INT_MEMC_TGT_ID), not cacheable, config ));
     546                     IntTab(cluster(x, y), INT_MEMC_TGT_ID), not cacheable, config ));
    535547
    536548         std::ostringstream    smemc_xram;
    537549         smemc_xram << "int_seg_memc_xram_" << x << "_" << y;
    538550         maptab_int.add(Segment(smemc_xram.str(), SEG_RAM_BASE+offset, SEG_RAM_SIZE,
    539                      IntTab(cluster(x,y), INT_MEMC_TGT_ID), cacheable));
     551                     IntTab(cluster(x, y), INT_MEMC_TGT_ID), cacheable));
    540552
    541553         std::ostringstream    sxicu;
    542554         sxicu << "int_seg_xicu_" << x << "_" << y;
    543555         maptab_int.add(Segment(sxicu.str(), SEG_XCU_BASE+offset, SEG_XCU_SIZE,
    544                      IntTab(cluster(x,y), INT_XICU_TGT_ID), not cacheable));
     556                     IntTab(cluster(x, y), INT_XICU_TGT_ID), not cacheable));
    545557
    546558         std::ostringstream    smdma;
    547559         smdma << "int_seg_mdma_" << x << "_" << y;
    548560         maptab_int.add(Segment(smdma.str(), SEG_DMA_BASE+offset, SEG_DMA_SIZE,
    549                      IntTab(cluster(x,y), INT_MDMA_TGT_ID), not cacheable));
     561                     IntTab(cluster(x, y), INT_MDMA_TGT_ID), not cacheable));
    550562
    551563         std::ostringstream    sbrom;
    552564         sbrom << "int_seg_brom_" << x << "_" << y;
    553565         maptab_int.add(Segment(sbrom.str(), SEG_ROM_BASE+offset, SEG_ROM_SIZE,
    554                      IntTab(cluster(x,y), INT_BROM_TGT_ID), cacheable));
     566                     IntTab(cluster(x, y), INT_BROM_TGT_ID), cacheable));
    555567
    556568         // the following segments are only defined in cluster_iob0 or in cluster_iob1
    557569
    558          if ( (cluster(x,y) == cluster_iob0) or (cluster(x,y) == cluster_iob1) )
     570         if ( (cluster(x, y) == cluster_iob0) or (cluster(x, y) == cluster_iob1) )
    559571         {
    560572            std::ostringstream    siobx;
    561573            siobx << "int_seg_iobx_" << x << "_" << y;
    562574            maptab_int.add(Segment(siobx.str(), SEG_IOB_BASE+offset, SEG_IOB_SIZE,
    563                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable, config ));
     575                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable, config ));
    564576
    565577            std::ostringstream    stty;
    566578            stty << "int_seg_mtty_" << x << "_" << y;
    567579            maptab_int.add(Segment(stty.str(), SEG_TTY_BASE+offset, SEG_TTY_SIZE,
    568                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     580                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    569581
    570582            std::ostringstream    sfbf;
    571583            sfbf << "int_seg_fbuf_" << x << "_" << y;
    572584            maptab_int.add(Segment(sfbf.str(), SEG_FBF_BASE+offset, SEG_FBF_SIZE,
    573                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     585                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    574586
    575587            std::ostringstream    sbdv;
    576588            sbdv << "int_seg_bdev_" << x << "_" << y;
    577589            maptab_int.add(Segment(sbdv.str(), SEG_IOC_BASE+offset, SEG_IOC_SIZE,
    578                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     590                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    579591
    580592            std::ostringstream    snic;
    581593            snic << "int_seg_mnic_" << x << "_" << y;
    582594            maptab_int.add(Segment(snic.str(), SEG_NIC_BASE+offset, SEG_NIC_SIZE,
    583                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     595                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    584596
    585597            std::ostringstream    sdma;
    586598            sdma << "int_seg_cdma_" << x << "_" << y;
    587599            maptab_int.add(Segment(sdma.str(), SEG_CMA_BASE+offset, SEG_CMA_SIZE,
    588                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     600                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    589601
    590602            std::ostringstream    spic;
    591603            spic << "int_seg_iopi_" << x << "_" << y;
    592604            maptab_int.add(Segment(spic.str(), SEG_PIC_BASE+offset, SEG_PIC_SIZE,
    593                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     605                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    594606
    595607            std::ostringstream    ssim;
    596608            ssim << "int_seg_simh_" << x << "_" << y;
    597609            maptab_int.add(Segment(ssim.str(), SEG_SIM_BASE+offset, SEG_SIM_SIZE,
    598                         IntTab(cluster(x,y), INT_IOBX_TGT_ID), not cacheable));
     610                        IntTab(cluster(x, y), INT_IOBX_TGT_ID), not cacheable));
    599611         }
    600612
     
    602614         // and the port index on the local interconnect.
    603615
    604          maptab_int.srcid_map( IntTab( cluster(x,y), MDMA_LOCAL_SRCID ),
    605                                IntTab( cluster(x,y), INT_MDMA_INI_ID ) );
    606 
    607          maptab_int.srcid_map( IntTab( cluster(x,y), IOBX_LOCAL_SRCID ),
    608                                IntTab( cluster(x,y), INT_IOBX_INI_ID ) );
    609 
    610          maptab_int.srcid_map( IntTab( cluster(x,y), IOPI_LOCAL_SRCID ),
    611                                IntTab( cluster(x,y), INT_IOBX_INI_ID ) );
     616         maptab_int.srcid_map( IntTab( cluster(x, y), MDMA_LOCAL_SRCID ),
     617                               IntTab( cluster(x, y), INT_MDMA_INI_ID ) );
     618
     619         maptab_int.srcid_map( IntTab( cluster(x, y), IOBX_LOCAL_SRCID ),
     620                               IntTab( cluster(x, y), INT_IOBX_INI_ID ) );
     621
     622         maptab_int.srcid_map( IntTab( cluster(x, y), IOPI_LOCAL_SRCID ),
     623                               IntTab( cluster(x, y), INT_IOBX_INI_ID ) );
    612624
    613625         for ( size_t p = 0 ; p < NB_PROCS_MAX ; p++ )
    614          maptab_int.srcid_map( IntTab( cluster(x,y), PROC_LOCAL_SRCID+p ),
    615                                IntTab( cluster(x,y), INT_PROC_INI_ID+p ) );
     626         maptab_int.srcid_map( IntTab( cluster(x, y), PROC_LOCAL_SRCID+p ),
     627                               IntTab( cluster(x, y), INT_PROC_INI_ID+p ) );
    616628      }
    617629   }
     
    635647        for (size_t y = 0; y < Y_SIZE ; y++)
    636648        {
    637             uint64_t offset = ((uint64_t)cluster(x,y))
     649            uint64_t offset = ((uint64_t)cluster(x, y))
    638650                                << (vci_address_width-X_WIDTH-Y_WIDTH);
    639651
     
    641653            sxram << "ext_seg_xram_" << x << "_" << y;
    642654            maptab_ram.add(Segment(sxram.str(), SEG_RAM_BASE+offset,
    643                            SEG_RAM_SIZE, IntTab(cluster(x,y), RAM_XRAM_TGT_ID), false));
     655                           SEG_RAM_SIZE, IntTab(cluster(x, y), RAM_XRAM_TGT_ID), false));
    644656        }
    645657    }
     
    745757            const bool cacheable = true;
    746758
    747             const uint64_t offset = ((uint64_t)cluster(x,y))
     759            const uint64_t offset = ((uint64_t)cluster(x, y))
    748760                << (vci_address_width-X_WIDTH-Y_WIDTH);
    749761
     
    10181030            std::cout << std::endl;
    10191031
    1020             const bool is_iob0 = (cluster(x,y) == cluster_iob0);
    1021             const bool is_iob1 = (cluster(x,y) == cluster_iob1);
     1032            const bool is_iob0 = (cluster(x, y) == cluster_iob0);
     1033            const bool is_iob1 = (cluster(x, y) == cluster_iob1);
    10221034            const bool is_io_cluster = is_iob0 || is_iob1;
    10231035
     
    10901102                frozen_cycles,
    10911103                debug_from,
    1092                 debug_ok and (cluster(x,y) == debug_memc_id),
    1093                 debug_ok and (cluster(x,y) == debug_proc_id),
     1104                debug_ok and (cluster(x, y) == debug_memc_id),
     1105                debug_ok and (cluster(x, y) == (debug_proc_id >> P_WIDTH)),
    10941106                debug_ok and debug_iob
    10951107            );
     
    11021114    }
    11031115#endif
     1116
     1117    // disable all interfaces of the faulty router
     1118    if (faulty_router_id != 0xFFFFFFFF)
     1119    {
     1120       int faulty_x = faulty_router_id >> Y_WIDTH;
     1121       int faulty_y = faulty_router_id & ((1 << Y_WIDTH) - 1);
     1122       clusters[faulty_x][faulty_y]->int_router_cmd[0]->set_disable_mask(0x1F);
     1123    }
    11041124
    11051125    std::cout << std::endl;
     
    14141434
    14151435   // simulation loop
    1416    struct timeval t1,t2;
     1436   struct timeval t1, t2;
    14171437
    14181438   // cycles between stats
     
    14571477         if ( debug_proc_id != 0xFFFFFFFF )
    14581478         {
    1459             size_t l          = debug_proc_id % NB_PROCS_MAX ;
    1460             size_t cluster_xy = debug_proc_id / NB_PROCS_MAX ;
    1461             size_t x          = cluster_xy >> 4;
    1462             size_t y          = cluster_xy & 0xF;
     1479            size_t l          = debug_proc_id & ((1 << P_WIDTH) - 1);
     1480            size_t cluster_xy = debug_proc_id >> P_WIDTH ;
     1481            size_t x          = cluster_xy >> Y_WIDTH;
     1482            size_t y          = cluster_xy & ((1 << Y_WIDTH) - 1);
    14631483
    14641484            clusters[x][y]->proc[l]->print_trace(1);
     
    14851505         if ( debug_memc_id != 0xFFFFFFFF )
    14861506         {
    1487             size_t x = debug_memc_id >> 4;
    1488             size_t y = debug_memc_id & 0xF;
     1507            size_t x = debug_memc_id >> Y_WIDTH;
     1508            size_t y = debug_memc_id & ((1 << Y_WIDTH) - 1);
    14891509
    14901510            clusters[x][y]->memc->print_trace(0);
     
    15061526         if ( debug_xram_id != 0xFFFFFFFF )
    15071527         {
    1508             size_t x = debug_xram_id >> 4;
    1509             size_t y = debug_xram_id & 0xF;
     1528            size_t x = debug_xram_id >> Y_WIDTH;
     1529            size_t y = debug_xram_id & ((1 << Y_WIDTH) - 1);
    15101530
    15111531            clusters[x][y]->xram->print_trace();
  • branches/reconfiguration/platforms/tsar_generic_iob/tsar_iob_cluster/caba/metadata/tsar_iob_cluster.sd

    r851 r855  
    7878              dspin_rsp_width    = parameter.Reference('dspin_int_rsp_width')),
    7979
    80         Uses('caba:dspin_router',
     80        Uses('caba:reconf:dspin_router',
    8181              flit_width         = parameter.Reference('dspin_int_cmd_width')),
    8282
    83         Uses('caba:dspin_router',
     83        Uses('caba:reconf:dspin_router',
    8484              flit_width         = parameter.Reference('dspin_int_rsp_width')),
    8585
     
    9595              dspin_rsp_width    = parameter.Reference('dspin_ram_rsp_width')),
    9696
    97         Uses('caba:dspin_router',
     97        Uses('caba:reconf:dspin_router',
    9898              flit_width         = parameter.Reference('dspin_ram_cmd_width')),
    9999
    100         Uses('caba:dspin_router',
     100        Uses('caba:reconf:dspin_router',
    101101              flit_width         = parameter.Reference('dspin_ram_rsp_width')),
    102102
Note: See TracChangeset for help on using the changeset viewer.