Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <limits.h>

#include <ctype.h>

#include <stdint.h>

#include <inttypes.h>

#include <verilated.h>          // Defines common routines

#include "Vtraffic.h"

#include "Vpck_inj.h"

#include <thread>

#include <vector>

#include <atomic>

#include <cstdint>

#include <cstdlib>

#include <iostream>

#include "simulator.h"

int main(int argc, char** argv) {

    char change_injection_ratio=0;

    int i,j,x,y;//,report_delay_counter=0;

    char deafult_out[] = {"result"};

    NEw=Log2(NE);

    for(i=0;i<NE;i++)   custom_traffic_table[i]=INJECT_OFF; //off

    Verilated::commandArgs(argc, argv);   // Remember args

    processArgs ( argc,  argv );

    allocate_rsv_pck_counters();

    if (class_percentage==NULL) {

            class_percentage =   (int *) malloc(sizeof(int));

            class_percentage[0]=100;

    }

    Vrouter_new();

    if (ENDP_TYPE == PCK_INJECTOR)    for(i=0;i<NE;i++)    pck_inj[i]  = new Vpck_inj;

    else                            for(i=0;i<NE;i++)    traffic[i]  = new Vtraffic;

    FIXED_SRC_DST_PAIR = strcmp (TRAFFIC,"RANDOM") &  strcmp(TRAFFIC,"HOTSPOT") & strcmp(TRAFFIC,"random") & strcmp(TRAFFIC,"hot spot") & strcmp(TRAFFIC,"TASK");

    /********************

    *    initialize input

    *********************/

    reset=1;

    reset_active_high=1;

    reset_all_register();

    start_i=0;

    mcast_init();

    topology_init();

    if( TRAFFIC_TYPE == NETRACE){

        netrace_init(netrace_file); // should be called first to initiate header

        pck_inj_init((int)header->num_nodes);

    }

    else if (TRAFFIC_TYPE ==SYNFUL) {

        pck_inj_init(SYNFUL_ENDP_NUM); //should be called first to initiate node mapping needed by synful lib

        synful_init(synful_file,synful_SSExit,synful_random_seed,sim_end_clk_num,end_sim_pck_num);

    }

    else     traffic_gen_init();

    main_time=0;

    print_parameter();

    if( thread_num>1) initial_threads();

    while (!Verilated::gotFinish()) {

        if(main_time - saved_time < 50) {//set reset and start

            reset_active_high = ((router1[0]->router_event[0] & ACTIVE_HIGH_RST)==1)? 1 : 0;

            if (main_time-saved_time >= 10 ) reset = (reset_active_high)? 0 :1;

            else reset = reset_active_high;     ;//keep system in reset

            if(main_time == saved_time+21){ count_en=1; start_i=1;}

            if(main_time == saved_time+23) start_i=0;

        }

        if(TRAFFIC_TYPE==NETRACE) netrace_posedge_event();

        else if(TRAFFIC_TYPE ==SYNFUL) synful_posedge_event();

        else traffic_clk_posedge_event();

        //The valus of all registers and input ports valuse change @ posedge of the clock. Once clk is deasserted,  as multiple modules are connected inside the testbench we need several eval for propogating combinational logic values

        //between modules when the clock .

        for (i=0;i<SMART_MAX+2;i++) {

            if(TRAFFIC_TYPE==NETRACE) netrace_negedge_event();

            else if(TRAFFIC_TYPE ==SYNFUL) synful_negedge_event();

            else traffic_clk_negedge_event( );

        }

        if(simulation_done){

            if( TRAFFIC_TYPE == NETRACE) netrace_final_report();

            else if(TRAFFIC_TYPE ==SYNFUL) synful_final_report();

            else traffic_gen_final_report();

            sim_final_all();

            return 0;

        }

        main_time++;

    }//Simulating is done

    sim_final_all();

    return 0;

}

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

void  usage(char * bin_name){

    printf("Usage:\n"

" %s -t <synthetic Traffic Pattern name> [synthetic Traffic options]\n"

" %s -f <Task file> [Task options]\n"

" %s -F <netrace file> [Netrace options] \n"

" %s -S <synful model file> [synful options]\n\n"

"synthetic Traffic options:\n"

"  -t <Traffic Pattern>        \"HOTSPOT\", \"RANDOM\", \"BIT_COMPLEMENT\" , \"BIT_REVERSE\",\n"

"                              \"TORNADO\", \"TRANSPOSE1\", \"TRANSPOSE2\", \"SHUFFEL\", \"CUSTOM\"\n"

"  -m <Packet size info>       packet size format  Random-Range or Random-discrete:\n"

"                              Random-Range : \"R,MIN,MAX\" : The injected packets' size in flits are\n"

"                              randomly selected in range MIN <= PCK_size <=MAX \n"

"                              Random-discrete: \"D,S1,S2,..Sn,P,P1,P2,P3,...Pn\": Si are the discrete\n"

"                              set of numbers representing packet size. The injected packet size is\n"

"                              randomly selected among these discrete values according to associated\n"

"                              probability values.\n"

"  -c <sim_end_clk_num>        The simulation will stop when the simulation clock number reaches this value\n"

"  -n <sim_end_pck_num>        The simulation will stop when the total sent packets to the NoC reaches this number\n"

"  -i <injection ratio>        flit injection ratio in percentage\n"

"  -p <class traffic ratios>   The percentage of traffic injected for each class. Represented in\n"

"                              comma-separated string format:\"n0,n1,n2..\" \n"

"  -h <HOTSPOT traffic format> represented in a string with the following format:\n"

"                              total number of hotspot nodes, first hotspot node ID, first hotspot node\n"

"                              send enable(1 or 0),first hotspot node percentage x10,second hotspot node ...\n"

"  -H <custom traffic pattern> custom traffic pattern: represented in a string with following format:\n"

"                              \"SRC1,DEST1, SRC2,DEST2, .., SRCn, DESTn\"   \n"

"  -T <thread-num>             total number of threads. The default is one (no-thread).\n"

"  -u <Multi/Broadcast format> represented in a string with following format:\n"

"                              \"ratio,min_pck_size,max_pck_size\"\n"

"                              ratio:The percentage of Multicast/broadcast packets against total injected \n"

"                              traffic. The Multicast/Broadcast packet size is randomly selected\n"

"                              between min_pck_size and max_pck_size. The max_pck_size must be smaller or equal\n"

"                              to the router buffer width. This filed is only valid when the NoC is configured\n"

"                              with the Multicast/Broadcast feature support.\n"

//"  -Q                          Quick (fast) simulation. ignore evaluating non-active routers \n"

//"                              to speed up simulation time"

"\nTrace options:\n"

"  -f <Task file>              Path to the task file. any custom task file can be generated using ProNoC gui\n"

"  -c <sim_end_clk_num>        Simulation will stop when simulation clock number reach this value \n"

"  -T <thread-num>             Total number of threads. The default is one (no-thread).\n"

//"  -Q                          Quick (fast) simulation. ignore evaluating non-active routers \n"

//"                              to speed up simulation time"

"\nNetrace options:\n"

"  -F <Netrace file>           Path to the task file. any custom task file can be generated using ProNoC gui\n"

"  -n <sim_end_pck_num>        The simulation will stop when the total sent packets to the NoC reaches this number\n"

"  -d                          ignore dependencies\n"

"  -r <start region>           Start region\n"

"  -l                          Reader throttling\n"

"  -v <level>                  Verbosity level. 0: off, 1:display a live number of injected packets,\n"

"                              3: print injected/ejected packets details, The default value is 1\n"

"  -T <thread-num>             Total number of threads. The default is one (no-thread).\n"

"  -s <speed-up-num>           The speed-up-num  is the ratio of netrace frequency to pronoc.The higher value\n"

"                              results in higher injection ratio to the NoC. Default is one\n"

//"  -Q                          Quick (fast) simulation. ignore evaluating non-active routers \n"

//"                              to speed up simulation time"

"\nsynful options:\n"

"  -S <model file>             Path to the synful application model file\n"

"  -r <seed value>             Seed value for random function\n"

"  -c <sim_end_clk_num>        The simulation will stop when the simulation clock number reaches this value \n"

"  -s                          Exit at steady state\n"

"  -n <sim_end_pck_num>        The simulation will stop when the total of sent packets to the NoC reaches this number\n"

"  -T <thread-num>             Total number of threads. The default is one (no-thread).\n"

"  -v <level>                  Verbosity level. 0: off, 1:display a live number of injected packets,\n"

"  -w <flit-size>              The synful flit size in Byte. It defines the number of flits that should be set to\n"

"                              ProNoC for each synful packets. The ProNoC packet size is:\n"

"                              Ceil(synful packet size/synful flit size).\n"

"                              3: print injected/ejected packets details, The default value is 1\n",

bin_name,bin_name,bin_name,bin_name

);

}

void netrace_processArgs (int argc, char **argv )

{

   char c;

   /* don't want getopt to moan - I can do that just fine thanks! */

   opterr = 0;

   if (argc < 2)  usage(argv[0]);

   while ((c = getopt (argc, argv, "F:dr:lv:T:n:s:")) != -1)

   {

     switch (c)

     {

         case 'F':

             TRAFFIC_TYPE=NETRACE;

             TRAFFIC=(char *) "NETRACE";

             ENDP_TYPE = PCK_INJECTOR;

             netrace_file = optarg;

             break;

         case 'd':

             ignore_dependencies=1;

             break;

         case 'r':

            start_region=atoi(optarg);

             break;

         case 'l':

             reader_throttling=1;

             break;

         case 'v':

             verbosity= atoi(optarg);

             break;

         case 'T':

            thread_num = atoi(optarg);

            break;

         case 'n':

             end_sim_pck_num=atoi(optarg);

             break;

         case 's':

             netrace_speed_up=atoi(optarg);

             break;

         case '?':

             if (isprint (optopt))

                 fprintf (stderr, "Unknown option `-%c'.\n", optopt);

             else

                 fprintf (stderr,  "Unknown option character `\\x%x'.\n",  optopt);

         default:

                usage(argv[0]);

                exit(1);

      }

    }

}

void synthetic_task_processArgs (int argc, char **argv )

{

   char c;

   int p;

   int array[10];

   float f;

   /* don't want getopt to moan - I can do that just fine thanks! */

   opterr = 0;

   if (argc < 2)  usage(argv[0]);

   while ((c = getopt (argc, argv, "t:m:n:c:i:p:h:H:f:T:u:Q")) != -1)

      {

     switch (c)

        {

         case 'f':

             TRAFFIC_TYPE=TASK;

             TRAFFIC=(char *) "TASK";

             task_traffic_init(optarg);

             break;

        case 't':

            TRAFFIC=optarg;

            total_active_routers=-1;

            break;

        case 's':

            MIN_PACKET_SIZE=atoi(optarg);

            break;

        case 'n':

             end_sim_pck_num=atoi(optarg);

             break;

        case 'c':

             sim_end_clk_num=atoi(optarg);

             break;

        case 'i':

             f=atof(optarg);

             f*=(MAX_RATIO/100);

             ratio= (int) f;

             break;

        case 'p':

            p= parse_string (optarg, array);

            if (p==0) {

                printf("Warning: class setting is ignored!\n");

                break;

            }

            class_percentage =   (int *) malloc( p * sizeof(int));

            for(int k=0;k<p;k++){

                class_percentage[k]=array[k];

            }

            if(p >1 && p>C){

                printf("Warning: the number of given class %u is larger than the number of message classes in ProNoC (C=%u)!\n",p,C);

            }

            break;

        case 'm':

            update_pck_size(optarg);

            break;

        case 'H':

            update_custom_traffic(optarg);

            break;

        case 'h':

            update_hotspot(optarg);

            break;

        case  'T':

            thread_num = atoi(optarg);

            break;

        case 'Q':

            //Quick_sim_en=1;

            fprintf (stderr, "Unknown option `-%c'.\n", optopt);

            usage(argv[0]);

            exit(1);

            break;

        case 'u':

            update_mcast_traffic(optarg);

            break;

        case '?':

           if (isprint (optopt))

          fprintf (stderr, "Unknown option `-%c'.\n", optopt);

           else

          fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt);

        default:

           usage(argv[0]);

           exit(1);

        }

      }

}

void synful_processArgs (int argc, char **argv)

{

   char c;

   /* don't want getopt to moan - I can do that just fine thanks! */

   opterr = 0;

   if (argc < 2)  usage(argv[0]);

   while ((c = getopt (argc, argv, "S:c:sn:v:T:r:w:")) != -1)

   {

     switch (c)

     {

         case 'S':

             TRAFFIC_TYPE=SYNFUL;

             TRAFFIC=(char *) "SYNFUL";

             synful_file = optarg;

             ENDP_TYPE   =PCK_INJECTOR;

             break;

         case 'c':

             sim_end_clk_num=atoi(optarg);

             break;

         case 's':

             synful_SSExit =true;

             break;

         case 'n':

             end_sim_pck_num=atoi(optarg);

             break;

         case 'v':

              verbosity= atoi(optarg);

              break;

         case 'w':

              synful_flitw= atoi(optarg);

              break;

         case 'T':

             thread_num = atoi(optarg);

             break;

         case 'r':

             synful_random_seed = atoi(optarg);

             break;

         case '?':

             if (isprint (optopt)) fprintf (stderr, "Unknown option `-%c'.\n", optopt);

             else fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt);

         default:

              usage(argv[0]);

              exit(1);

     }//switch

   }//while

}

int parse_string ( char * str, int * array)

{

    int i=0;

    char *pt;

    pt = strtok (str,",");

    while (pt != NULL) {

        int a = atoi(pt);

        array[i]=a;

        i++;

        pt = strtok (NULL, ",");

    }

   return i;

}

unsigned int pck_dst_gen_unicast (     unsigned int core_num, unsigned char * inject_en) {

    if(TRAFFIC_TYPE==TASK)    return      pck_dst_gen_task_graph ( core_num, inject_en);

    if((strcmp (TOPOLOGY,"MESH")==0)||(strcmp (TOPOLOGY,"TORUS")==0))    return  pck_dst_gen_2D (core_num, inject_en);

    return pck_dst_gen_1D (core_num, inject_en);

}

void mcast_full_rnd (unsigned int core_num){

    unsigned int rnd;

    int a;

    for(;;)  {

        DEST_ADDR_ASSIGN_RAND(traffic[core_num]->dest_e_addr);

        if((strcmp (SELF_LOOP_EN,"NO")==0)) DEST_ADDR_BIT_CLR(traffic[core_num]->dest_e_addr,core_num);

        DEST_ADDR_IS_ZERO(a,traffic[core_num]->dest_e_addr);

        //rnd = rand() & ~(0x1<<core_num);

        //rnd &= ((1<<NE) -1);

        //if(rnd!=0) return rnd;

        if(a!=1) return;

    }

}

void mcast_partial_rnd (unsigned int core_num){

    unsigned int rnd;int a;

    //printf("m[%d]=%d\n",core_num,mcast_list_array[core_num]);

    if(mcast_list_array[core_num] == 1){ // the current node is located in multicast partial list

        unsigned int self_node_addr = endp_id_to_mcast_id(core_num);//current node location in multicast list

        self_node_addr++;

        for(;;){

            DEST_ADDR_ASSIGN_RAND(traffic[core_num]->dest_e_addr);

            DEST_ADDR_BIT_CLR(traffic[core_num]->dest_e_addr,0);

            if((strcmp (SELF_LOOP_EN,"NO")==0))    DEST_ADDR_BIT_CLR(traffic[core_num]->dest_e_addr,self_node_addr);

            //rnd = rand() & ~((0x1<<(self_node_addr+1))|0x1); // generate a random multicast destination. remove the current node flag and unicast_flag from destination list

            //rnd &= ((1<<(MCAST_PRTLw+1)) -1);

            //printf("rnd=%d\n",rnd);

            DEST_ADDR_IS_ZERO(a,traffic[core_num]->dest_e_addr);

            if(a!=1) return;

            //if(rnd!=0) return rnd;

        }

    }else{

        for(;;){

            DEST_ADDR_ASSIGN_RAND(traffic[core_num]->dest_e_addr);

            DEST_ADDR_BIT_CLR(traffic[core_num]->dest_e_addr,0);

            DEST_ADDR_IS_ZERO(a,traffic[core_num]->dest_e_addr);

            if(a!=1) return;

            //rnd = rand() & ~0x1;// deassert the unicast flag

            //rnd &= ((1<<(MCAST_PRTLw+1)) -1);

            //if(rnd!=0) return rnd;

        }

    }

//this function should not come here

}

void pck_dst_gen (     unsigned int core_num, unsigned char * inject_en) {

    unsigned int dest = pck_dst_gen_unicast (core_num, inject_en);

//    printf("inject_en=%u, core_num=%u, dest=%u\n",*inject_en, core_num,dest);

    if(IS_UNICAST){

        traffic[core_num]->dest_e_addr= dest;

        return;

    }

    else if (*inject_en==0) return;

    //multicast

    DEST_ADDR_ASSIGN_ZERO(traffic[core_num]->dest_e_addr);//reset traffic[core_num]->dest_e_addr

    unsigned int dest_id = endp_addr_decoder (dest);

    //*inject_en = dest_id !=core_num;

    unsigned int rnd = rand() % 100; // 0~99

    if(rnd >= mcast.ratio){

        //send a unicast packet

        if((strcmp (SELF_LOOP_EN,"NO")==0) && dest_id==core_num){

            *inject_en=0;

            return;

        }

        if(IS_MCAST_FULL){

            //return (0x1<<dest_id);// for mcast-full

            DEST_ADDR_BIT_SET(traffic[core_num]->dest_e_addr,dest_id);

            return;

        }

        // IS_MCAST_PARTIAL | IS_BCAST_FULL | IS_BCAST_PARTIAL

        dest = (dest << 1) | 0x1; // {dest_coded,unicast_flag}

        DEST_ADDR_ASSIGN_INT(traffic[core_num]->dest_e_addr,dest);

        return;

    }

    traffic[core_num]->pck_size_in=rnd_between(mcast.min,mcast.max);

    if (IS_MCAST_FULL) {

        mcast_full_rnd (core_num);

        return;

    }

    if (IS_MCAST_PARTIAL){

        mcast_partial_rnd(core_num);

        return;

    }

    return; //IS_BCAST_FULL | IS_BCAST_PARTIAL  traffic[core_num]->dest_e_addr=0;

}

void update_hotspot(char * str){

     int i;

     int array[1000];

     int p;

     int acuum=0;

     hotspot_st * new_node;

     p= parse_string (str, array);

     if (p<4){

            fprintf(stderr,"ERROR: in hotspot traffic parameters. 4 value should be given as hotspot parameter\n");

            exit(1);

     }

     HOTSPOT_NUM=array[0];

     if (p<1+HOTSPOT_NUM*3){

            fprintf(stderr,"ERROR: in hotspot traffic parameters \n");

            exit(1);

     }

     new_node =  (hotspot_st *) malloc( HOTSPOT_NUM * sizeof(hotspot_st));

     if( new_node == NULL){

         fprintf(stderr,"ERROR: cannot allocate memory for hotspot traffic\n");

           exit(1);

        }

     for (i=1;i<3*HOTSPOT_NUM; i+=3){

        new_node[i/3]. ip_num = array[i];

        new_node[i/3]. send_enable=array[i+1];

        new_node[i/3]. percentage =  acuum + array[i+2];

        acuum= new_node[i/3]. percentage;

     }

     if(acuum> 1000){

             printf("Warning: The hotspot traffic summation %f exceed than 100 percent.  \n", (float) acuum /10);

     }

     hotspots=new_node;

}

void  update_mcast_traffic(char * str){

    int i;

    int array[10];

    int p;

    int max_valid =(B > LB)? LB : B;

    p= parse_string (str, array);

    if(p>0)    mcast.ratio =array[0];

    if(p>1)    mcast.min =array[1];

    if(p>2)    mcast.max =array[2];

    if (mcast.ratio > 100)       { printf("ERROR: The given multicast traffic ratio (%d) is larger than 100\n",mcast.ratio);     exit(1);}

    if (mcast.min < MIN_PCK_SIZE){ printf("ERROR: The given multicast minimum packet size (%d) is larger than %d minimum packet size supported by the NoC\n",mcast.min, MIN_PCK_SIZE);     exit(1);}

    if (mcast.max > max_valid)   { printf("ERROR: The given multicast maximum packet size (%d) is larger than %d maximum router buffer size\n",mcast.max, max_valid);     exit(1);};

}

void update_custom_traffic (char * str){

    int i;

    int array[10000];

    int p;

    p= parse_string (str, array);

    for (i=0;i<p; i+=2){

        custom_traffic_table[array[i]] = array[i+1];

    }

}

void update_pck_size(char *str){

    int i;

    int array[1000];

    char substring[1000];

    int p;

    char *pt,*pt2;

    MIN_PACKET_SIZE=100000;

    MAX_PACKET_SIZE=1;

    pt = strtok (str,",");

    if(*pt=='R'){//random range

        p= parse_string (str+2, array);

        if(p<2){

            fprintf(stderr,"ERROR: Wrong Packet size format %s. It should be \"R,min,max\" : \n",str);

            exit(1);

        }

        MIN_PACKET_SIZE=array[0];

        MAX_PACKET_SIZE=array[1];

        AVG_PACKET_SIZE=(MIN_PACKET_SIZE+MAX_PACKET_SIZE)/2;// average packet size

    }else if(*pt=='D'){//random discrete

        pck_size_sel =  RANDOM_discrete;

        pt = strtok (str+2,"P");

        pt2 = strtok (NULL,"P");

        if (pt == NULL || pt2==NULL) {

            fprintf(stderr,"ERROR: Wrong Packet size format %s. It should be \"D,s1,s2..sn,P,p1,p2..pn\". missing letter \"P\" in format  \n",str);

            exit(1);

        }

        p= parse_string (pt, array);

        if (p==0){

            fprintf(stderr,"ERROR: Wrong Packet size format %s. It should be \"D,s1,s2..sn,P,p1,p2..pn\". missing si values after letter \"D\" \"P\" in format  \n",str);

            exit(1);

        }

        int in=p;

        //alocate mmeory for pck size