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_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 >= 10 ) {

                        reset = 0;

                }

                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);

        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

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

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

                // Check if the memory has been successfully allocated

                if (discrete_size == NULL || discrete_prob==NULL) {