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

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <ctype.h>

#include <stdint.h>

#include <inttypes.h>

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

#include "Vrouter.h"               // From Verilating "router.v"

#include "Vnoc.h"

#include "Vtraffic.h"

#include "parameter.h"

//#include "traffic_tabel.h"

#define  NC             (NX*NY)

#define  RATIO_INIT             2

unsigned char FIXED_SRC_DST_PAIR;

unsigned char  Xw=0,Yw=0;

//Vrouter *router;

Vrouter                 *router[NC];                     // Instantiation of module

Vnoc                    *noc;

Vtraffic                *traffic[NC];

unsigned long int main_time = 0;     // Current simulation time

unsigned int saved_time = 0;

unsigned int total_pck_num=0;

unsigned int sum_clk_h2h,sum_clk_h2t;

double           sum_clk_per_hop;

const int  CC=(C==0)? 1 : C;

unsigned int total_pck_num_per_class[CC]={0};

unsigned int sum_clk_h2h_per_class[CC]={0};

unsigned int sum_clk_h2t_per_class[CC]={0};

double           sum_clk_per_hop_per_class[CC]={0};

unsigned int clk_counter;

unsigned int count_en;

unsigned int total_router;

char all_done=0;

unsigned int flit_counter =0;

char ratio=RATIO_INIT;

double first_avg_latency_flit,current_avg_latency_flit;

double sc_time_stamp ();

int pow2( int );

int reset,clk;

#if (STND_DEV_EN)

        #include <math.h>

        double       sum_clk_pow2=0;

        double       sum_clk_pow2_per_class[C]={0};

        double standard_dev( double , unsigned int, double);

#endif

void update_noc_statistic (

        unsigned int,

        unsigned int,

    unsigned int,

    unsigned int

);

void pck_dst_gen (

    unsigned int,

        unsigned int,

        unsigned int,

        unsigned int*,

        unsigned int*

);

unsigned char pck_class_in_gen(

         unsigned int

);

void print_statistic (char *);

void print_parameter();

void reset_all_register();

char * TRAFFIC;

int PACKET_SIZE;

int MAX_PCK_NUM;

int MAX_SIM_CLKs;

int inject_ratios[100];

int C0_p=100, C1_p=0, C2_p=0, C3_p=0;

int  HOTSPOT_PERCENTAGE;

int  HOTSPOT_NUM;

int  HOTSPOT_CORE_1, HOTSPOT_CORE_2, HOTSPOT_CORE_3, HOTSPOT_CORE_4,HOTSPOT_CORE_5;

void  usage(){

        printf(" ./simulator -t [Traffic Pattern]  -s  [PACKET_SIZE]  -n  [MAX_PCK_NUM]  c      [MAX_SIM_CLKs]   -i [INJECTION_RATIO] -p [class traffic ratios %]  -h[HOTSPOT info] \n");

        printf("      Traffic Pattern: \"HOTSPOT\" \"RANDOM\" \"TORNADO\" \"BIT_REVERSE\"  \"BIT_COMPLEMENT\"  \"TRANSPOSE1\"   \"TRANSPOSE2\"\n");

        printf("      PACKET_SIZE: packet size in flit\n ");

        printf("      MAX_PCK_NUM: total number of sent packets. Simulation will stop when total of sent packet by all nodes reach this number\n");

        printf("      MAX_SIM_CLKs: simulation clock limit. Simulation will stop when simulation clock number reach this value \n");

        printf("      INJECTION_RATIO: packet injection ratios");

        printf("      class traffic ratios %: The percentage of traffic injected for each class. represented in string whit each clas ratio is seprated by coma. \"n0,n1,n2..\" \n");

        printf("      HOTSPOT info: represented in a string with following format:  \"HOTSPOT_PERCENTAGE,HOTSOPT_NUM,HOTSPOT_CORE_1,HOTSPOT_CORE_2,HOTSPOT_CORE_3,HOTSPOT_CORE_4,HOTSPOT_CORE_5\" \n");

}

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;

}

void processArgs (int argc, char **argv )

{

   char c;

   int p;

   int array[10];

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

   opterr = 0;

   if (argc < 2)  usage();

   while ((c = getopt (argc, argv, "t:s:n:c:i:p:h:")) != -1)

      {

         switch (c)

            {

            case 't':

                        TRAFFIC=optarg;

                        break;

                case 's':

                        PACKET_SIZE=atoi(optarg);

                        break;

                case 'n':

                         MAX_PCK_NUM=atoi(optarg);

                         break;

                case 'c':

                         MAX_SIM_CLKs=atoi(optarg);

                         break;

                case 'i':

                         ratio=atoi(optarg);

                         break;

                case 'p':

                        p= parse_string (optarg, array);

                    C0_p=array[0];

                    C1_p=array[1];

                    C2_p=array[2];

                    C3_p=array[3];

                        break;

                case 'h':

                         p= parse_string (optarg, array);

                         HOTSPOT_PERCENTAGE=array[0];

                         HOTSPOT_NUM=array[1];

                         HOTSPOT_CORE_1=array[2];

                         HOTSPOT_CORE_2=array[3];

                         HOTSPOT_CORE_3=array[4];

                         HOTSPOT_CORE_4=array[5];

                         HOTSPOT_CORE_5=array[6];

                         break;

            case '?':

               if (isprint (optopt))

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

               else

                  fprintf (stderr,

                           "Unknown option character `\\x%x'.\n",

                           optopt);

            default:

               usage();

               exit(1);

            }

      }

}

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

        char change_injection_ratio=0,inject_done;

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

        char file_name[100];

        char deafult_out[] = {"result"};

        char * out_file_name;

        unsigned int dest_x, dest_y;

        int flit_out_all_size = sizeof(router[0]->flit_out_all)/sizeof(router[0]->flit_out_all[0]);

        while((0x1<<Xw) < NX)Xw++; //log2

        while((0x1<<Yw) < NY)Yw++;

        processArgs ( argc,  argv );

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

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

        for(i=0;i<NC;i++)        router[i]       = new Vrouter;             // Create instance

        noc                                                             = new Vnoc;

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

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

        *       initialize input

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

        reset=1;

        reset_all_register();

        noc->start_i=0;

        for(x=0;x<NX;x++)for(y=0;y<NY;y++){

                                        i=(y*NX)+x;

                                        router[i]->current_x            = x;

                                        router[i]->current_y            = y;

                                        traffic[i]->current_x           = x;

                                        traffic[i]->current_y           = y;

                                        traffic[i]->start=0;

                                        traffic[i]->pck_size_in=PACKET_SIZE;

                                        traffic[i]->ratio=ratio;

                                        traffic[i]->pck_class_in=  pck_class_in_gen( i);

                                        pck_dst_gen ( x,y,i, &dest_x, &dest_y);

                                        traffic[i]->dest_x= dest_x;

                                        traffic[i]->dest_y=dest_y;

        }

        main_time=0;

        print_parameter();

        printf("\n\n\n Flit injection ratio per router is =%d \n",ratio);

        //printf("\n\n\n delay= %u clk",router->delay);

        while (!Verilated::gotFinish()) {

                if (main_time-saved_time >= 10 ) {

                        reset = 0;

                }

                if(main_time == saved_time+21){ count_en=1; noc->start_i=1;}//for(i=0;i<NC;i++) traffic[i]->start=1;}

                if(main_time == saved_time+26) noc->start_i=0;// for(i=0;i<NC;i++) traffic[i]->start=0;

                if ((main_time % 4) == 0) {

                        clk = 1;       // Toggle clock

                        if(count_en) clk_counter++;

                        inject_done= ((total_pck_num >= MAX_PCK_NUM) || (clk_counter>= MAX_SIM_CLKs));

                        //if(inject_done) printf("clk_counter=========%d\n",clk_counter);

                        for(x=0;x<NX;x++)for(y=0;y<NY;y++)

                        {

                                i=(y*NX)+x;

                                // a packet has been received

                                if(traffic[i]->update & ~reset){

                                        update_noc_statistic (

                                                traffic[i]->time_stamp_h2h,

                                                traffic[i]->time_stamp_h2t,

                                                traffic[i]->distance,

                                                traffic[i]->pck_class_out

                                        ) ;

                                }

                                // the header flit has been sent out

                                if(traffic[i]->hdr_flit_sent ){

                                        traffic[i]->pck_class_in=  pck_class_in_gen( i);

                                        if(!FIXED_SRC_DST_PAIR){

                                                pck_dst_gen ( x,y,i, &dest_x, &dest_y);

                                                traffic[i]->dest_x= dest_x;

                                                traffic[i]->dest_y=dest_y;

                                        }

                                }

                                if(traffic[i]->flit_out_wr==1) flit_counter++;

                        }//for

                        if(inject_done) {

                                for(x=0;x<NX;x++)for(y=0;y<NY;y++) if(traffic[(y*NX)+x]->pck_number>0) total_router        =       total_router +1;

                                printf(" simulation clock cycles:%d\n",clk_counter);

                                printf(" total received flits:%d\n",flit_counter);

                                print_statistic(out_file_name);

                                change_injection_ratio = 1;

                                for(i=0;i<NC;i++) {

                                        router[i]->final();

                                        traffic[i]->final();

                                }

                                noc->final();

                                return 0;

                        }

                }//if

                else

                {

                        clk = 0;

                        noc->ni_flit_in_wr =0;

                        for(x=0;x<NX;x++)for(y=0;y<NY;y++){

                                i=(y*NX)+x;

                                router[i]->flit_in_we_all       = noc->router_flit_out_we_all[i];

                                router[i]->credit_in_all        = noc->router_credit_out_all[i];

                                router[i]->congestion_in_all    = noc->router_congestion_out_all[i];

                                for(j=0;j<flit_out_all_size;j++)router[i]->flit_in_all[j]        = noc->router_flit_out_all[i][j];

                                noc->router_flit_in_we_all[i]   =       router[i]->flit_out_we_all ;

                                noc->router_credit_in_all[i]    =       router[i]->credit_out_all;

                                noc->router_congestion_in_all[i]=       router[i]->congestion_out_all;

                                for(j=0;j<flit_out_all_size;j++) noc->router_flit_in_all[i][j]   = router[i]->flit_out_all[j] ;

                                traffic[i]->flit_in  = noc->ni_flit_out [i];

                                traffic[i]->credit_in= noc->ni_credit_out[i];

                                noc->ni_credit_in[i] = traffic[i]->credit_out;

                                noc->ni_flit_in [i]  = traffic[i]->flit_out;

                                if(traffic[i]->flit_out_wr) noc->ni_flit_in_wr = noc->ni_flit_in_wr | ((vluint64_t)1<<i);

                                traffic[i]->flit_in_wr= ((noc->ni_flit_out_wr >> i) & 0x01);

                        }//for

                }//else

                //if(main_time > 20 && main_time < 30 ) traffic->start=1; else traffic->start=0;

                //if(main_time == saved_time+25) router[0]->flit_in_we_all=0;

                //if((main_time % 250)==0) printf("router->all_done =%u\n",router->all_done);

                noc-> clk = clk;

                noc-> reset = reset;

                for(i=0;i<NC;i++)        {

                        traffic[i]->start=  ((noc->start_o >>i)&  0x01);

                        traffic[i]->reset= reset;

                        traffic[i]->clk = clk;

                        router[i]->reset= reset;

                        router[i]->clk= clk ;

                }

                noc->eval();

                for(i=0;i<NC;i++) {

                                router[i]->eval();

                                traffic[i]->eval();

                }

                //router[0]->eval();            // Evaluate model

                //printf("clk=%x\n",router->clk );

                main_time++;

                //getchar();   

        }

        for(i=0;i<NC;i++) {

                router[i]->final();

                traffic[i]->final();

        }               // Done simulating

        noc->final();

}

double sc_time_stamp () {       // Called by $time in Verilog

        return main_time;

}

int pow2( int num){

        int pw;

        pw= (0x1 << num);

        return pw;

}

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

 *

 *      update_noc_statistic

 *

 *

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

void update_noc_statistic (

                unsigned int    clk_num_h2h,

                unsigned int    clk_num_h2t,

        unsigned int    distance,

        unsigned int    class_num

)

{

                        total_pck_num+=1;

                        //if((total_pck_num & 0Xffff )==0 ) printf("total_pck_num=%d\n",total_pck_num);

                        sum_clk_h2h+=clk_num_h2h;

                        sum_clk_h2t+=clk_num_h2t;

#if (STND_DEV_EN)

                        sum_clk_pow2+=(double)clk_num_h2h * (double) clk_num_h2h;

                        sum_clk_pow2_per_class[class_num]+=(double)clk_num_h2h * (double) clk_num_h2h;

#endif

                        sum_clk_per_hop+= ((double)clk_num_h2h/(double)distance);

                        total_pck_num_per_class[class_num]+=1;

                        sum_clk_h2h_per_class[class_num]+=clk_num_h2h ;

                        sum_clk_h2t_per_class[class_num]+=clk_num_h2t ;

                        sum_clk_per_hop_per_class[class_num]+= ((double)clk_num_h2h/(double)distance);

        }

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

 *

 *              update

 *

 *

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

void print_statistic (char * out_file_name){

        double avg_latency_per_hop,  avg_latency_flit, avg_latency_pck, avg_throughput,min_avg_latency_per_class;

        int i;

#if (STND_DEV_EN)

        double  std_dev;

#endif

                                        char file_name[100];

                                        avg_throughput= ((double)(total_pck_num*PACKET_SIZE*100)/total_router )/clk_counter;

                                        printf(" Total active routers: %d \n",total_router);

                                        printf(" Avg throughput is: %f (flits/clk/node %%)\n",    avg_throughput);

                        avg_latency_flit   = (double)sum_clk_h2h/total_pck_num;

                        avg_latency_pck    = (double)sum_clk_h2t/total_pck_num;

                        if(ratio==RATIO_INIT) first_avg_latency_flit=avg_latency_flit;

#if (STND_DEV_EN)

                        std_dev= standard_dev( sum_clk_pow2,total_pck_num, avg_latency_flit);

                       // sprintf(file_name,"%s_std.txt",out_file_name);

                        //update_file( file_name,avg_throughput,std_dev);

#endif

                        avg_latency_per_hop    = (double)sum_clk_per_hop/total_pck_num;

                        printf   ("\nall : \n");

                      //  sprintf(file_name,"%s_all.txt",out_file_name);

                        //update_file(file_name ,ratio,avg_latency );

if(strcmp (AVG_LATENCY_METRIC,"HEAD_2_TAIL")==0){

                        printf(" Total number of packet = %d \n average latency per hop = %f \n average latency = %f\n",total_pck_num,avg_latency_per_hop,avg_latency_pck);

                      // update_file(file_name ,avg_throughput,avg_latency_pck);

}else{

                         printf(" Total number of packet = %d \n average latency per hop = %f \n average latency = %f\n",total_pck_num,avg_latency_per_hop,avg_latency_flit);

                     //   update_file(file_name ,avg_throughput,avg_latency_flit);

}

                        //fwrite(fp,"%d,%f,%f,%f,",total_pck_num,avg_latency_per_hop,avg_latency,max_latency_per_hop);

                        min_avg_latency_per_class=1000000;

                        for(i=0;i<C;i++){

                                avg_throughput           = (total_pck_num_per_class[i]>0)? ((double)(total_pck_num_per_class[i]*PACKET_SIZE*100)/total_router )/clk_counter:0;

                                                avg_latency_flit         = (total_pck_num_per_class[i]>0)? (double)sum_clk_h2h_per_class[i]/total_pck_num_per_class[i]:0;

                                                avg_latency_pck          = (total_pck_num_per_class[i]>0)? (double)sum_clk_h2t_per_class[i]/total_pck_num_per_class[i]:0;

                                                avg_latency_per_hop  = (total_pck_num_per_class[i]>0)? (double)sum_clk_per_hop_per_class[i]/total_pck_num_per_class[i]:0;

if(strcmp (AVG_LATENCY_METRIC,"HEAD_2_TAIL")==0){

                                                 printf  ("\nclass : %d  \n",i);

                            printf      (" Total number of packet  = %d \n avg_throughput = %f \n average latency per hop = %f \n average latency = %f\n",total_pck_num_per_class[i],avg_throughput,avg_latency_per_hop,avg_latency_pck);

                            //sprintf(file_name,"%s_c%u.txt",out_file_name,i);

                           // update_file( file_name,avg_throughput,avg_latency_pck );

}else{

printf   ("\nclass : %d  \n",i);

                            printf      (" Total number of packet  = %d \n avg_throughput = %f \n average latency per hop = %f \n average latency = %f\n",total_pck_num_per_class[i],avg_throughput,avg_latency_per_hop,avg_latency_flit);

                           // sprintf(file_name,"%s_c%u.txt",out_file_name,i);

                           // update_file( file_name,avg_throughput,avg_latency_flit );

}

                            if(min_avg_latency_per_class > avg_latency_flit) min_avg_latency_per_class=avg_latency_flit;

#if (STND_DEV_EN)

                            std_dev= (total_pck_num_per_class[i]>0)?  standard_dev( sum_clk_pow2_per_class[i],total_pck_num_per_class[i], avg_latency_flit):0;

                           // sprintf(file_name,"%s_std%u.txt",out_file_name,i);

                           // update_file( file_name,avg_throughput,std_dev);

#endif

                         }//for

                        current_avg_latency_flit=min_avg_latency_per_class;

}

void print_parameter (){

                printf ("Router parameters: \n");

                printf ("\tTopology: %s\n",TOPOLOGY);

                printf ("\tRouting algorithm: %s\n",ROUTE_NAME);

                printf ("\tVC_per port: %d\n", V);

                printf ("\tBuffer_width: %d\n", B);

            printf ("\tRouter num in row: %d \n",NX);

            printf ("\tRouter num in column: %d \n",NY);

            printf ("\tNumber of Class: %d\n", C);

            printf ("\tFlit data width: %d \n", Fpay);

            printf ("\tVC reallocation mechanism: %s \n",  VC_REALLOCATION_TYPE);

            printf ("\tVC/sw combination mechanism: %s \n", COMBINATION_TYPE);

            printf ("\troute-subfunction: %s \n", ROUTE_SUBFUNC );

            printf ("\tAVC_ATOMIC_EN:%d \n", AVC_ATOMIC_EN);

            printf ("\tCongestion Index:%d \n",CONGESTION_INDEX);

            printf ("\tADD_PIPREG_AFTER_CROSSBAR:%d\n",ADD_PIPREG_AFTER_CROSSBAR);

#if(DEBUG_EN)

            printf ("\tDebuging is enabled\n");

#else

            printf ("\tDebuging is disabled\n");

#endif

        printf ("Simulation parameters\n");

        if(strcmp (AVG_LATENCY_METRIC,"HEAD_2_TAIL")==0)printf ("\tOutput is the average latency on sending the packet head until receiving tail\n");

        else printf ("\tOutput is the average latency on sending the packet head until receiving the head\n");

        printf ("\tTraffic pattern:%s\n",TRAFFIC);

        if(C>0) printf ("\ttraffic percentage of class 0 is : %d\n", C0_p);

        if(C>1) printf ("\ttraffic percentage of class 1 is : %d\n", C1_p);

        if(C>2) printf ("\ttraffic percentage of class 2 is : %d\n", C2_p);

        if(C>3) printf ("\ttraffic percentage of class 3 is : %d\n", C3_p);

        if((strcmp (TRAFFIC,"HOTSPOT")==0)|| (strcmp (TRAFFIC,"hot spot")==0)){

                printf ("\tHot spot percentage: %u\n", HOTSPOT_PERCENTAGE);

            printf ("\tNumber of hot spot cores: %d\n", HOTSPOT_NUM);

        }

            //printf ("\tTotal packets sent by one router: %u\n", TOTAL_PKT_PER_ROUTER);

                printf ("\t Simulation timeout =%d\n", MAX_SIM_CLKs);

                printf ("\t Simulation ends on total packet num of =%d\n", MAX_PCK_NUM);

            printf ("\tPacket size: %u flits\n",PACKET_SIZE);

            printf ("\t SSA_EN enabled:%s \n",SSA_EN);

}

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

 *

 *      reset system

 *

 *

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

void reset_all_register (void){

        int i;