URL https://opencores.org/ocsvn/an-fpga-implementation-of-low-latency-noc-based-mpsoc/an-fpga-implementation-of-low-latency-noc-based-mpsoc/trunk

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

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [src_verilator/] [simulator.cpp] - Blame information for rev 42

Go to most recent revision | Details | Compare with Previous | View Log


#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 "Vrouter.h"               // From Verilating "router.v"
#include "Vnoc.h"
#include "Vtraffic.h"
#include "parameter.h"
 
 
 
#ifndef  NC 
#define  NC             (NX*NY)
#endif
 
#define  RATIO_INIT             2
 
#define SYNTHETIC 0
#define CUSTOM 1 
#define DISABLE -1
 
#define MY_VL_SETBIT_W(data,bit) (data[VL_BITWORD_I(bit)] |= (VL_UL(1) << VL_BITBIT_I(bit)))
 
#include "traffic_task_graph.h"
 
#define STND_DEV_EN 1
 
 
//Vrouter *router;
Vrouter                 *router[NC];                     // Instantiation of module
Vnoc                    *noc;
Vtraffic                *traffic[NC];
 
 
char * TRAFFIC;
unsigned char FIXED_SRC_DST_PAIR;
unsigned char  Xw=0,Yw=0;
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 rsvd_core_total_pck_num[NC]= {0};
unsigned int rsvd_core_worst_delay[NC] =  {0};
unsigned int sent_core_total_pck_num[NC]= {0};
unsigned int sent_core_worst_delay[NC] =  {0};
unsigned int random_var[NC] = {100};
 
unsigned int clk_counter;
unsigned int count_en;
unsigned int total_router;
 
int reset,clk;
 
char all_done=0;
 
unsigned int flit_counter =0;
 
int ratio=RATIO_INIT;
double first_avg_latency_flit,current_avg_latency_flit;
 
double sc_time_stamp ();
int pow2( int );
 
 
 
 
 
#if (STND_DEV_EN)
        //#include <math.h>
        double sqroot (double s){
                int i;
                double root = s/3;
                if (s<=0) return 0;
                for(i=0;i<32;i++) root = (root +s/root)/2;
                return root;
        }
 
        double       sum_clk_pow2=0;
        double       sum_clk_pow2_per_class[C];
        double standard_dev( double , unsigned int, double);
#endif
 
void update_noc_statistic (
        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();
unsigned int rnd_between (unsigned int, unsigned int );
 
 
 
 
 
 
 
int TRAFFIC_TYPE=SYNTHETIC;
int PACKET_SIZE=5;
int MIN_PACKET_SIZE=5;
int MAX_PACKET_SIZE=5;
int MAX_PCK_NUM;
int MAX_SIM_CLKs;
 
int C0_p=100, C1_p=0, C2_p=0, C3_p=0;
 
 
int  HOTSPOT_NUM;
typedef struct HOTSPOT_NODE {
        int  ip_num;
        char send_enable;
        int  percentage; // x10 
} hotspot_st;
 
hotspot_st * hotspots;
 
 
 
 
 
void  usage(){
        printf(" ./simulator -f [Traffic Pattern file]\n\nor\n");
 
 
        printf(" ./simulator -t [Traffic Pattern]  -s  [MIN_PCK_SIZE] -m [MAX_PCK_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("      MIN_PCK_SIZE: Minimum packet size in flit. The injected packet size is randomly selected between minimum and maximum packet size\n ");
        printf("      MAX_PCK_SIZE: Maximum packet size in flit. The injected packet size is randomly selected between minimum and maximum packet size\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 ratio");
        printf("      class traffic ratios %%: The percentage of traffic injected for each class. represented in string whit each class ratio is separated by comma. \"n0,n1,n2..\" \n");
        printf("      hotspot traffic info: represented in a string with following format:  \"HOTSPOT PERCENTAGE,HOTSPOT NUM,HOTSPOT CORE 1,HOTSPOT CORE 2,HOTSPOT CORE 3,HOTSPOT CORE 4,HOTSPOT CORE 5, ENABLE HOTSPOT CORES SEND \"   \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 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){
                        printf("Error in hotspot traffic parameters \n");
                        exit(1);
         }
         HOTSPOT_NUM=array[0];
         if (p<1+HOTSPOT_NUM*3){
                        printf("Error in hotspot traffic parameters \n");
                        exit(1);
         }
         new_node =  (hotspot_st *) malloc( HOTSPOT_NUM * sizeof(hotspot_st));
         if( new_node == NULL){
        printf("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 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();
   while ((c = getopt (argc, argv, "t:s:m:n:c:i:p:h:f:")) != -1)
      {
         switch (c)
            {
                case 'f':
                        TRAFFIC_TYPE=CUSTOM;
                        TRAFFIC=(char *) "CUSTOM from file";
                        load_traffic_file(optarg,task_graph_data,task_graph_abstract);
                        MAX_PCK_NUM=task_graph_total_pck_num;
                        break;
            case 't':
                        TRAFFIC=optarg;
                        total_active_routers=-1;
                        break;
                case 's':
                        MIN_PACKET_SIZE=atoi(optarg);
                        break;
                case 'm':
                        MAX_PACKET_SIZE=atoi(optarg);
                        break;
                case 'n':
                         MAX_PCK_NUM=atoi(optarg);
                         break;
                case 'c':
                         MAX_SIM_CLKs=atoi(optarg);
                         break;
                case 'i':
                         f=atof(optarg);
                         f*=(MAX_RATIO/100);
                         ratio= (int) f;
                         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':
 
                        update_hotspot(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();
               exit(1);
            }
      }
   PACKET_SIZE=(MIN_PACKET_SIZE+MAX_PACKET_SIZE)/2;// average packet size
}
 
 
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++;
 
 
        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;
 
        processArgs ( argc,  argv );
 
 
        FIXED_SRC_DST_PAIR = strcmp (TRAFFIC,"RANDOM") &  strcmp(TRAFFIC,"HOTSPOT") & strcmp(TRAFFIC,"random") & strcmp(TRAFFIC,"hot spot") & strcmp(TRAFFIC,"CUSTOM from file");
 
 
        /********************
        *       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;
                                        random_var[i] = 100;
                                        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_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;
                                        traffic[i]->stop=0;
                                        if(TRAFFIC_TYPE==SYNTHETIC){
                                                traffic[i]->pck_size_in=PACKET_SIZE;
                                                traffic[i]->avg_pck_size_in=PACKET_SIZE;
                                                traffic[i]->ratio=ratio;
                                                traffic[i]->init_weight=1;
                                        }
 
 
        }
        //traffic[35]->init_weight=10;
 
 
 
        main_time=0;
        print_parameter();
        if(strcmp(TRAFFIC,"CUSTOM from file")) printf("\n\n\n Flit injection ratio per router is =%f \n",(float)ratio*100/MAX_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) || total_active_routers == 0);
                        //if(inject_done) printf("clk_counter=========%d\n",clk_counter);
                        for(y=0;y<NY;y++)for(x=0;x<NX;x++)
                        {
                                i=(y*NX)+x;
                                // a packet has been received
                                if(traffic[i]->update & ~reset){
                                        update_noc_statistic (i) ;
 
                                }
                                // the header flit has been sent out
                                if(traffic[i]->hdr_flit_sent ){
                                        traffic[i]->pck_class_in=  pck_class_in_gen( i);
                                        sent_core_total_pck_num[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;
#if (NC<=64)                            
                        noc->ni_flit_in_wr =0;
#else
                        for(j=0;j<(sizeof(noc->ni_flit_in_wr)/sizeof(noc->ni_flit_in_wr[0])); j++) noc->ni_flit_in_wr[j]=0;
#endif                  
                        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];
                                //router[i]->iport_weight_in_all        = noc->router_iport_weight_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;
                                //noc->router_iport_weight_in_all[i]=   router[i]->iport_weight_out_all;
 
                                for(j=0;j<flit_out_all_size;j++) noc->router_flit_in_all[i][j]   = router[i]->flit_out_all[j] ;
#if (Fpay<=32)
                                traffic[i]->flit_in  = noc->ni_flit_out [i];
#else   
        for(j=0;j<(sizeof(traffic[i]->flit_out)/sizeof(traffic[i]->flit_out[0])); j++) traffic[i]->flit_in[j]  = noc->ni_flit_out [i][j];
#endif                                  
                                traffic[i]->credit_in= noc->ni_credit_out[i];
 
 
                                noc->ni_credit_in[i] = traffic[i]->credit_out;
#if (Fpay<=32)                          
                                noc->ni_flit_in [i]  = traffic[i]->flit_out;
#else   
        for(j=0;j<(sizeof(traffic[i]->flit_out)/sizeof(traffic[i]->flit_out[0])); j++) noc->ni_flit_in [i][j]  = traffic[i]->flit_out[j];
#endif
 
#if (NC<=64)                    
                                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);
#else
                                if(traffic[i]->flit_out_wr) MY_VL_SETBIT_W(noc->ni_flit_in_wr ,i);
                                traffic[i]->flit_in_wr=   (VL_BITISSET_W(noc->ni_flit_out_wr,i)>0);
#endif
 
 
 
                        }//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++)        {
#if (NC<=64)                    
                        traffic[i]->start=  ((noc->start_o >>i)&  0x01);
#else
                        traffic[i]->start=   (VL_BITISSET_W(noc->start_o, i)>0);
#endif                  
                        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();
 
}
 
 
 
 
/*************
 * sc_time_stamp
 *
 * **********/
 
 
 
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 (
 
                int                     core_num
)
{
 
        unsigned int    clk_num_h2h =traffic[core_num]->time_stamp_h2h;
        unsigned int    clk_num_h2t =traffic[core_num]->time_stamp_h2t;
    unsigned int    distance=traffic[core_num]->distance;
    unsigned int        class_num=traffic[core_num]->pck_class_out;
    unsigned int    src_x=traffic[core_num]->src_x;
    unsigned int    src_y=traffic[core_num]->src_y;
 
    unsigned int    src = (src_y*NX)+src_x;
 
 
 
 
        total_pck_num+=1;
 
        if((total_pck_num & 0Xffff )==0 ) printf(" packet sent total=%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);
 
        rsvd_core_total_pck_num[core_num]=rsvd_core_total_pck_num[core_num]+1;
 
        if (rsvd_core_worst_delay[core_num] < clk_num_h2t) rsvd_core_worst_delay[core_num] = (strcmp (AVG_LATENCY_METRIC,"HEAD_2_TAIL")==0)?  clk_num_h2t :  clk_num_h2h;
    if (sent_core_worst_delay[src] < clk_num_h2t) sent_core_worst_delay[src] = (strcmp (AVG_LATENCY_METRIC,"HEAD_2_TAIL")==0)?  clk_num_h2t :  clk_num_h2h;
 
 
}
 
/*************************
 *
 *              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)(flit_counter*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);
                        printf(" standard_dev = %f\n",std_dev);
 
                       // 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;
 
        for (i=0;i<NC;i++) {
                printf   ("\n\nCore %d\n",i);
                        printf   ("\n\ttotal number of received packets: %u\n",rsvd_core_total_pck_num[i]);
                        printf   ("\n\tworst-case-delay of received pckets (clks): %u\n",rsvd_core_worst_delay[i] );
                        printf   ("\n\ttotal number of sent packets: %u\n",traffic[i]->pck_number);
                        printf   ("\n\tworst-case-delay of sent pckets (clks): %u\n",sent_core_worst_delay[i] );
        }
 
 
 
}
 
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);
            printf ("\tSSA_EN enabled:%s \n",SSA_EN);
            printf ("\tSwitch allocator arbitration type:%s \n",SWA_ARBITER_TYPE);
 
 
        printf ("\nSimulation parameters\n");
#if(DEBUG_EN)
    printf ("\tDebuging is enabled\n");
#else
    printf ("\tDebuging is disabled\n");
#endif
        if(strcmp (AVG_LATENCY_METRIC,"HEAD_2_TAIL")==0)printf ("\tOutput is the average latency on sending the packet header until receiving tail\n");
        else printf ("\tOutput is the average latency on sending the packet header until receiving header flit at destination node\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){
                //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 ("\tSimulation timeout =%d\n", MAX_SIM_CLKs);
                printf ("\tSimulation ends on total packet num of =%d\n", MAX_PCK_NUM);
            printf ("\tPacket size (min,max,average) in flits: (%u,%u,%u)\n",MIN_PACKET_SIZE,MAX_PACKET_SIZE,PACKET_SIZE);
            printf ("\tPacket injector FIFO width in flit:%u \n",TIMSTMP_FIFO_NUM);
}
 
 
 
 
 
/************************
 *
 *      reset system
 *
 *
 * *******************/
 
void reset_all_register (void){
        int i;
 
 
 
         total_router=0;
         total_pck_num=0;
         sum_clk_h2h=0;
         sum_clk_h2t=0;
#if (STND_DEV_EN)
         sum_clk_pow2=0;
#endif
 
         sum_clk_per_hop=0;
         count_en=0;
         clk_counter=0;
 
         for(i=0;i<C;i++)
         {
                 total_pck_num_per_class[i]=0;
             sum_clk_h2h_per_class[i]=0;
             sum_clk_h2t_per_class[i]=0;
                 sum_clk_per_hop_per_class[i]=0;
#if (STND_DEV_EN)
                 sum_clk_pow2_per_class[i]=0;
#endif
 
         }  //for
         flit_counter=0;
}
 
 
 
 
/***********************
 *
 *      standard_dev
 *
 * ******************/
 
#if (STND_DEV_EN)
/************************
 * std_dev = sqrt[(B-A^2/N)/N]  = sqrt [(B/N)- (A/N)^2] = sqrt [B/N - mean^2]
 * A = sum of the values
 * B = sum of the squarded values
 * *************/
 
double standard_dev( double sum_pow2, unsigned int  total_num, double average){
        double std_dev;
 
        /*
        double  A, B, N;
        N= total_num;
        A= average * N;
        B= sum_pow2;
 
        A=(A*A)/N;
        std_dev = (B-A)/N;
        std_dev = sqrt(std_dev);
*/
 
        std_dev = sum_pow2/(double)total_num; //B/N
        std_dev -= (average*average);// (B/N) - mean^2
        std_dev = sqroot(std_dev);// sqrt [B/N - mean^2]
 
        return std_dev;
 
}
 
#endif
 
 
 
/**********************
 *
 *      pck_class_in_gen
 *
 * *****************/
 
unsigned char  pck_class_in_gen(
         unsigned int  core_num
 
) {
 
        unsigned char pck_class_in;
        unsigned char  rnd=rand()%100;
 
        pck_class_in=     ( rnd <    C0_p               )?  0:
                                  ( rnd <   (C0_p+C1_p) )?      1:
                                  ( rnd <   (C0_p+C1_p+C2_p))?2:3;
 
 
 
    return pck_class_in;
}
 
 
/**********************************
 
        pck_dst_gen
 
*********************************/
 
 
 
 
void pck_dst_gen_2D (
    unsigned int current_x,
        unsigned int current_y,
        unsigned int core_num,
        unsigned int *dest_x,
        unsigned int *dest_y
){
 
 
        unsigned int rnd=0,nc=NX*NY;
        unsigned int rnd100=0;
        unsigned int max_percent=100/HOTSPOT_NUM;
        int i;
 
        traffic[core_num]->pck_size_in=rnd_between(MIN_PACKET_SIZE,MAX_PACKET_SIZE);
 
        if((strcmp (TRAFFIC,"RANDOM")==0) || (strcmp (TRAFFIC,"random")==0)){
 
                do{
                        rnd=rand()%nc;
                }while (rnd==core_num); // get a random IP core, make sure its not same as sender core
 
       (*dest_y) = (rnd / NX );
           (*dest_x) = (rnd % NX );
 
 
        }
 
        else if ((strcmp(TRAFFIC,"HOTSPOT")==0) || (strcmp (TRAFFIC,"hot spot")==0)){
 
                unsigned int rnd1000=0;
                int i;
 
 
                do{
                        rnd=rand()%nc;
                }while (rnd==core_num); // get a random IP core, make sure its not same as sender core
 
                rnd1000=rand()%1000; // generate a random number between 0 & 1000
 
                for (i=0;i<HOTSPOT_NUM; i++){
                        if ( hotspots[i].send_enable == 0 && core_num ==hotspots[i].ip_num){
                                rnd = core_num; // turn off the core
                                (*dest_y) = (rnd / NX );
                                (*dest_x) = (rnd % NX );
                                return;
                        }
                }
 
                for (i=0;i<HOTSPOT_NUM; i++){
                        if (rnd1000 < hotspots[i].percentage && core_num !=hotspots[i].ip_num) {
                                rnd = hotspots[i].ip_num;
                                (*dest_y) = (rnd / NX );
                                (*dest_x) = (rnd % NX );
                                return;
                        }
 
                }
                (*dest_y) = (rnd / NX );
                (*dest_x) = (rnd % NX );
                return;
 
 
        } else if(( strcmp(TRAFFIC ,"TRANSPOSE1")==0)|| (strcmp (TRAFFIC,"transposed 1")==0)){
 
                 (*dest_x) = NX-current_y-1;
                 (*dest_y) = NY-current_x-1;
 
 
 
        } else if(( strcmp(TRAFFIC ,"TRANSPOSE2")==0)|| (strcmp (TRAFFIC,"transposed 2")==0)){
                (*dest_x)   = current_y;
                (*dest_y)   = current_x;
 
 
 
        } else if(( strcmp(TRAFFIC ,"BIT_REVERSE")==0)|| (strcmp (TRAFFIC,"bit reverse")==0)){
                unsigned int joint_addr= (current_x<<Xw)+current_y;
                unsigned int reverse_addr=0;
                unsigned int pos=0;
                for(i=0; i<(Xw+Yw); i++){//reverse the address
                         pos= (((Xw+Yw)-1)-i);
                         reverse_addr|= ((joint_addr >> pos) & 0x01) << i;
                   // reverse_addr[i]  = joint_addr [((Xw+Yw)-1)-i];
                }
                (*dest_x)   = reverse_addr>>Yw;
                (*dest_y)   = reverse_addr&(0xFF>> (8-Yw));
 
 
 
 
         } else if(( strcmp(TRAFFIC ,"BIT_COMPLEMENT") ==0)|| (strcmp (TRAFFIC,"bit complement")==0)){
 
                 (*dest_x)    = (~current_x) &(0xFF>> (8-Xw));
                 (*dest_y)    = (~current_y) &(0xFF>> (8-Yw));
 
 
          }  else if(( strcmp(TRAFFIC ,"TORNADO") == 0)|| (strcmp (TRAFFIC,"tornado")==0)){
                //[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],
                 (*dest_x)    = ((current_x + ((NX/2)-1))%NX);
                 (*dest_y)    = ((current_y + ((NY/2)-1))%NY);
 
 
     }  else if( strcmp(TRAFFIC ,"CUSTOM") == 0){
                //[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],
                if(current_x ==0 && current_y == 0 ){
                 (*dest_x)    =  NX-1;
                 (*dest_y)    =  NY-1;
                }else{// make it invalid
                 (*dest_x)    =  current_x;
                 (*dest_y)    =  current_y;
 
                }
 
     }
 
         else {
                 printf ("traffic %s is an unsupported traffic pattern\n",TRAFFIC);
                 (*dest_x)    =  current_x;
                 (*dest_y)    =  current_y;
 
         }
 
}
 
 
 
 
void pck_dst_gen_1D (
    unsigned int current_x,
        unsigned int core_num,
        unsigned int *dest_x
 
){
 
 
        unsigned int rnd=0,nc=NX;
        unsigned int rnd100=0;
        unsigned int max_percent=100/HOTSPOT_NUM;
        int i;
 
        traffic[core_num]->pck_size_in=rnd_between(MIN_PACKET_SIZE,MAX_PACKET_SIZE);
 
        if((strcmp (TRAFFIC,"RANDOM")==0) || (strcmp (TRAFFIC,"random")==0)){
 
                do{
                        rnd=rand()%nc;
                }while (rnd==core_num); // get a random IP core, make sure its not same as sender core
 
           (*dest_x) = (rnd % NX );
                return;
 
        }
 
        if ((strcmp(TRAFFIC,"HOTSPOT")==0) || (strcmp (TRAFFIC,"hot spot")==0)){
 
                unsigned int rnd1000=0;
                int i;
 
 
                do{
                        rnd=rand()%nc;
                }while (rnd==core_num); // get a random IP core, make sure its not same as sender core
 
                rnd1000=rand()%1000; // generate a random number between 0 & 1000
 
                for (i=0;i<HOTSPOT_NUM; i++){
                        //printf("%u==0 && %u == %u\n", hotspots[i].send_enable , core_num , hotspots[i].ip_num);
                        if ( hotspots[i].send_enable == 0 && core_num ==hotspots[i].ip_num){
                                rnd = core_num; // turn off the core
                                (*dest_x) = (rnd % NX );
                                return;
                        }
                }
 
                for (i=0;i<HOTSPOT_NUM; i++){
                        //printf("%u<%u && %u |= %u\n", rnd1000 , hotspots[i].percentage , core_num ,hotspots[i].ip_num);
                        if (rnd1000 < hotspots[i].percentage && core_num !=hotspots[i].ip_num) {
                                rnd = hotspots[i].ip_num;
                                (*dest_x) = (rnd % NX );
                                return;
                        }
 
                }
        (*dest_x) = (rnd % NX );
                return;
 
        }
 
 
        if(( strcmp(TRAFFIC ,"TRANSPOSE1")==0)|| (strcmp (TRAFFIC,"transposed 1")==0)){
 
                 //(*dest_x) = (current_x<4)? NX-current_x-1: current_x;
                  (*dest_x) =  NX-current_x-1;
                // (*dest_y) = NY-current_x-1;
                return;
 
 
        }
        if(( strcmp(TRAFFIC ,"TRANSPOSE2")==0)|| (strcmp (TRAFFIC,"transposed 2")==0)){
                 (*dest_x) = NX-current_x-1;
        //      (*dest_x)   = current_y;
        //      (*dest_y)   = current_x;
                return;
 
        }
 
        if(( strcmp(TRAFFIC ,"BIT_REVERSE")==0)|| (strcmp (TRAFFIC,"bit reverse")==0)){
 
                unsigned int reverse_addr=0;
                unsigned int pos=0;
                for(i=0; i<(Xw); i++){//reverse the address
                         pos= (((Xw)-1)-i);
                         reverse_addr|= ((current_x >> pos) & 0x01) << i;
                   // reverse_addr[i]  = joint_addr [((Xw+Yw)-1)-i];
                }
                (*dest_x)   = reverse_addr;
                return;
 
         }
 
         if(( strcmp(TRAFFIC ,"BIT_COMPLEMENT") ==0)|| (strcmp (TRAFFIC,"bit complement")==0)){
 
                 (*dest_x)    = (~current_x) &(0xFF>> (8-Xw));
                 return;
                 //(*dest_y)    = (~current_y) &(0xFF>> (8-Yw));
 
 
         }
 
         if(( strcmp(TRAFFIC ,"TORNADO") == 0)|| (strcmp (TRAFFIC,"tornado")==0)){
                //[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],
                 (*dest_x)    = ((current_x + ((NX/2)-1))%NX);
                // (*dest_y)    = ((current_y + ((NY/2)-1))%NY);
                return;
 
     }
 
     if( strcmp(TRAFFIC ,"CUSTOM") == 0){
                //[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],
                if(current_x ==0  ){
                 (*dest_x)    =  NX-1;
                // (*dest_y)    =  NY-1;
                }else{// make it invalid
                 (*dest_x)    =  current_x;
                 //(*dest_y)    =  current_y;
 
                }
                return;
     }
 
 
                 printf ("traffic %s is an unsupported traffic pattern\n",TRAFFIC);
                 (*dest_x)    =  current_x;
 
 
}
 
unsigned int rnd_between (unsigned int a, unsigned int b){
        unsigned int rnd,diff,min;
        if(a==b) return a;
        diff= (a<b) ?  b-a+1 : a-b+1;
        min= (a<b) ?  a : b;
        rnd = (rand() % diff) +  min;
        return rnd;
}
 
void update_injct_var(unsigned int src,  unsigned int injct_var){
        //printf("before%u=%u\n",src,random_var[src]);
        random_var[src]= rnd_between(100-injct_var, 100+injct_var);
        //printf("after=%u\n",random_var[src]);
}
 
unsigned int pck_dst_gen_task_graph ( unsigned int src){
         task_t  task;
        float f,v;
 
 
 
 
        int index = task_graph_abstract[src].active_index;
 
        if(index == DISABLE){
                traffic[src]->ratio=0;
                traffic[src]->stop=1;
                 return src; //disable sending
        }
 
        if(     read(task_graph_data[src],index,&task)==0){
                traffic[src]->ratio=0;
                traffic[src]->stop=1;
                 return src; //disable sending
 
        }
 
        if(sent_core_total_pck_num[src] & 0xFF){//sent 255 packets
                        //printf("uu=%u\n",task.jnjct_var);
                        update_injct_var(src, task.jnjct_var);
 
                }
 
        task_graph_total_pck_num++;
        task.pck_sent = task.pck_sent +1;
        task.burst_sent= task.burst_sent+1;
        task.byte_sent = task.byte_sent + (task.avg_pck_size * (Fpay/8) );
 
        traffic[src]->pck_class_in=  pck_class_in_gen(src);
        traffic[src]->avg_pck_size_in=task.avg_pck_size;
        traffic[src]->pck_size_in=rnd_between(task.min_pck_size,task.max_pck_size);
 
        f=  task.injection_rate;
        v= random_var[src];
        f*= (v /100);
        if(f>100) f= 100;
        f=  f * MAX_RATIO / 100;
 
        traffic[src]->ratio=(unsigned int)f;
        traffic[src]->init_weight=task.initial_weight;
 
 
 
 
        if (task.burst_sent >= task.burst_size){
                task.burst_sent=0;
                task_graph_abstract[src].active_index=task_graph_abstract[src].active_index+1;
                if(task_graph_abstract[src].active_index>=task_graph_abstract[src].total_index) task_graph_abstract[src].active_index=0;
 
        }
 
 
        update_by_index(task_graph_data[src],index,task);
 
        if (task.byte_sent  >= task.bytes){ // This task is done remove it from the queue
                                remove_by_index(&task_graph_data[src],index);
                                task_graph_abstract[src].total_index = task_graph_abstract[src].total_index-1;
                                if(task_graph_abstract[src].total_index==0){ //all tasks are done turned off the core
                                        task_graph_abstract[src].active_index=-1;
                                        traffic[src]->ratio=0;
                                        traffic[src]->stop=1;
                                        if(total_active_routers!=0) total_active_routers--;
                                        return src;
                                }
                                if(task_graph_abstract[src].active_index>=task_graph_abstract[src].total_index) task_graph_abstract[src].active_index=0;
        }
 
        return task.dst;
 
 
 
 
}
 
 
 
 
void pck_dst_gen (
    unsigned int current_x,
        unsigned int current_y,
        unsigned int core_num,
        unsigned int *dest_x,
        unsigned int *dest_y
){
 
        if(TRAFFIC_TYPE==CUSTOM){
                int dest =      pck_dst_gen_task_graph ( core_num);
                 (*dest_y) = (dest / NX );
                 (*dest_x) = (dest % NX );
                // printf ("%d->%d (%d,%d)\n",core_num,dest,(*dest_y),(*dest_x) );      
                return;
 
        }
 
 
        if((strcmp (TOPOLOGY,"MESH")==0)||(strcmp (TOPOLOGY,"TORUS")==0)){
                pck_dst_gen_2D (
                    current_x,
                        current_y,
                        core_num,
                        dest_x,
                        dest_y
                );
                return;
        }
 
        dest_y=0;
        pck_dst_gen_1D (
                        current_x,
                        core_num,
                        dest_x);
 
}
 
 
 
 

Line No.	Rev	Author	Line
1	32	alirezamon	`#include <stdlib.h>`
2			`#include <stdio.h>`
3			`#include <unistd.h>`
4			`#include <string.h>`
5	41	alirezamon	`#include <limits.h>`
6	32	alirezamon	`#include <ctype.h>`
7			`#include <stdint.h>`
8			`#include <inttypes.h>`
9
10
11			`#include <verilated.h> // Defines common routines`
12			`#include "Vrouter.h" // From Verilating "router.v"`
13			`#include "Vnoc.h"`
14			`#include "Vtraffic.h"`
15	38	alirezamon	`#include "parameter.h"`
16	32	alirezamon
17
18
19	41	alirezamon	`#ifndef NC`
20	32	alirezamon	`#define NC (NX*NY)`
21	38	alirezamon	`#endif`
22	41	alirezamon
23	32	alirezamon	`#define RATIO_INIT 2`
24
25	38	alirezamon	`#define SYNTHETIC 0`
26			`#define CUSTOM 1`
27			`#define DISABLE -1`
28	32	alirezamon
29	41	alirezamon	`#define MY_VL_SETBIT_W(data,bit) (data[VL_BITWORD_I(bit)] \|= (VL_UL(1) << VL_BITBIT_I(bit)))`
30
31	38	alirezamon	`#include "traffic_task_graph.h"`
32	32	alirezamon
33	42	alirezamon	`#define STND_DEV_EN 1`
34	32	alirezamon
35
36			`//Vrouter *router;`
37			`Vrouter *router[NC]; // Instantiation of module`
38			`Vnoc *noc;`
39			`Vtraffic *traffic[NC];`
40
41	38	alirezamon
42			`char * TRAFFIC;`
43			`unsigned char FIXED_SRC_DST_PAIR;`
44			`unsigned char Xw=0,Yw=0;`
45	32	alirezamon	`unsigned long int main_time = 0; // Current simulation time`
46			`unsigned int saved_time = 0;`
47			`unsigned int total_pck_num=0;`
48			`unsigned int sum_clk_h2h,sum_clk_h2t;`
49			`double sum_clk_per_hop;`
50			`const int CC=(C==0)? 1 : C;`
51
52			`unsigned int total_pck_num_per_class[CC]={0};`
53			`unsigned int sum_clk_h2h_per_class[CC]={0};`
54			`unsigned int sum_clk_h2t_per_class[CC]={0};`
55			`double sum_clk_per_hop_per_class[CC]={0};`
56	38	alirezamon
57			`unsigned int rsvd_core_total_pck_num[NC]= {0};`
58			`unsigned int rsvd_core_worst_delay[NC] = {0};`
59			`unsigned int sent_core_total_pck_num[NC]= {0};`
60			`unsigned int sent_core_worst_delay[NC] = {0};`
61			`unsigned int random_var[NC] = {100};`
62
63	32	alirezamon	`unsigned int clk_counter;`
64			`unsigned int count_en;`
65			`unsigned int total_router;`
66
67	38	alirezamon	`int reset,clk;`
68	32	alirezamon
69			`char all_done=0;`
70
71			`unsigned int flit_counter =0;`
72
73	38	alirezamon	`int ratio=RATIO_INIT;`
74	32	alirezamon	`double first_avg_latency_flit,current_avg_latency_flit;`
75
76			`double sc_time_stamp ();`
77			`int pow2( int );`
78
79
80
81
82	38	alirezamon
83	32	alirezamon	`#if (STND_DEV_EN)`
84	42	alirezamon	`//#include <math.h>`
85			`double sqroot (double s){`
86			`int i;`
87			`double root = s/3;`
88			`if (s<=0) return 0;`
89			`for(i=0;i<32;i++) root = (root +s/root)/2;`
90			`return root;`
91			`}`
92
93	32	alirezamon	`double sum_clk_pow2=0;`
94	42	alirezamon	`double sum_clk_pow2_per_class[C];`
95	32	alirezamon	`double standard_dev( double , unsigned int, double);`
96			`#endif`
97
98			`void update_noc_statistic (`
99	38	alirezamon	`int`
100	32	alirezamon	`);`
101
102
103			`void pck_dst_gen (`
104			`unsigned int,`
105			`unsigned int,`
106			`unsigned int,`
107			`unsigned int*,`
108			`unsigned int*`
109			`);`
110
111			`unsigned char pck_class_in_gen(`
112			`unsigned int`
113
114			`);`
115
116
117
118
119			`void print_statistic (char *);`
120			`void print_parameter();`
121	38	alirezamon	`void reset_all_register();`
122			`unsigned int rnd_between (unsigned int, unsigned int );`
123	32	alirezamon
124
125
126
127
128	38	alirezamon
129
130			`int TRAFFIC_TYPE=SYNTHETIC;`
131			`int PACKET_SIZE=5;`
132			`int MIN_PACKET_SIZE=5;`
133			`int MAX_PACKET_SIZE=5;`
134	32	alirezamon	`int MAX_PCK_NUM;`
135			`int MAX_SIM_CLKs;`
136	38	alirezamon
137	32	alirezamon	`int C0_p=100, C1_p=0, C2_p=0, C3_p=0;`
138
139
140			`int HOTSPOT_NUM;`
141	38	alirezamon	`typedef struct HOTSPOT_NODE {`
142			`int ip_num;`
143			`char send_enable;`
144			`int percentage; // x10`
145			`} hotspot_st;`
146	32	alirezamon
147	38	alirezamon	`hotspot_st * hotspots;`
148
149
150
151
152
153	32	alirezamon	`void usage(){`
154	38	alirezamon	`printf(" ./simulator -f [Traffic Pattern file]\n\nor\n");`
155
156
157			`printf(" ./simulator -t [Traffic Pattern] -s [MIN_PCK_SIZE] -m [MAX_PCK_SIZE] -n [MAX_PCK_NUM] c [MAX SIM CLKs] -i [INJECTION RATIO] -p [class traffic ratios (%%)] -h[HOTSPOT info] \n");`
158	32	alirezamon	`printf(" Traffic Pattern: \"HOTSPOT\" \"RANDOM\" \"TORNADO\" \"BIT_REVERSE\" \"BIT_COMPLEMENT\" \"TRANSPOSE1\" \"TRANSPOSE2\"\n");`
159	38	alirezamon	`printf(" MIN_PCK_SIZE: Minimum packet size in flit. The injected packet size is randomly selected between minimum and maximum packet size\n ");`
160			`printf(" MAX_PCK_SIZE: Maximum packet size in flit. The injected packet size is randomly selected between minimum and maximum packet size\n ");`
161
162	32	alirezamon	`printf(" MAX_PCK_NUM: total number of sent packets. Simulation will stop when total of sent packet by all nodes reach this number\n");`
163			`printf(" MAX_SIM_CLKs: simulation clock limit. Simulation will stop when simulation clock number reach this value \n");`
164	38	alirezamon	`printf(" INJECTION_RATIO: packet injection ratio");`
165			`printf(" class traffic ratios %%: The percentage of traffic injected for each class. represented in string whit each class ratio is separated by comma. \"n0,n1,n2..\" \n");`
166			`printf(" hotspot traffic info: represented in a string with following format: \"HOTSPOT PERCENTAGE,HOTSPOT NUM,HOTSPOT CORE 1,HOTSPOT CORE 2,HOTSPOT CORE 3,HOTSPOT CORE 4,HOTSPOT CORE 5, ENABLE HOTSPOT CORES SEND \" \n");`
167	32	alirezamon	`}`
168
169
170			`int parse_string ( char * str, int * array)`
171			`{`
172			`int i=0;`
173			`char *pt;`
174			`pt = strtok (str,",");`
175			`while (pt != NULL) {`
176			`int a = atoi(pt);`
177			`array[i]=a;`
178			`i++;`
179			`pt = strtok (NULL, ",");`
180			`}`
181			`return i;`
182			`}`
183
184	38	alirezamon	`void update_hotspot(char * str){`
185			`int i;`
186			`int array[1000];`
187			`int p;`
188			`int acuum=0;`
189			`hotspot_st * new_node;`
190			`p= parse_string (str, array);`
191			`if (p<4){`
192			`printf("Error in hotspot traffic parameters \n");`
193			`exit(1);`
194			`}`
195			`HOTSPOT_NUM=array[0];`
196			`if (p<1+HOTSPOT_NUM*3){`
197			`printf("Error in hotspot traffic parameters \n");`
198			`exit(1);`
199			`}`
200			`new_node = (hotspot_st ) malloc( HOTSPOT_NUM sizeof(hotspot_st));`
201			`if( new_node == NULL){`
202			`printf("Error: cannot allocate memory for hotspot traffic\n");`
203			`exit(1);`
204			`}`
205			`for (i=1;i<3*HOTSPOT_NUM; i+=3){`
206			`new_node[i/3]. ip_num = array[i];`
207			`new_node[i/3]. send_enable=array[i+1];`
208			`new_node[i/3]. percentage = acuum + array[i+2];`
209			`acuum= new_node[i/3]. percentage;`
210
211			`}`
212			`if(acuum> 1000){`
213			`printf("Warning: The hotspot traffic summation %f exceed than 100 percent. \n", (float) acuum /10);`
214
215			`}`
216
217			`hotspots=new_node;`
218			`}`
219
220
221
222
223
224
225
226	32	alirezamon	`void processArgs (int argc, char **argv )`
227			`{`
228			`char c;`
229			`int p;`
230			`int array[10];`
231	38	alirezamon	`float f;`
232	32	alirezamon
233			`/* don't want getopt to moan - I can do that just fine thanks! */`
234			`opterr = 0;`
235			`if (argc < 2) usage();`
236	38	alirezamon	`while ((c = getopt (argc, argv, "t:s:m:n:c:i:p:h:f:")) != -1)`
237	32	alirezamon	`{`
238			`switch (c)`
239			`{`
240	38	alirezamon	`case 'f':`
241			`TRAFFIC_TYPE=CUSTOM;`
242			`TRAFFIC=(char *) "CUSTOM from file";`
243			`load_traffic_file(optarg,task_graph_data,task_graph_abstract);`
244			`MAX_PCK_NUM=task_graph_total_pck_num;`
245			`break;`
246	32	alirezamon	`case 't':`
247			`TRAFFIC=optarg;`
248	38	alirezamon	`total_active_routers=-1;`
249	32	alirezamon	`break;`
250			`case 's':`
251	38	alirezamon	`MIN_PACKET_SIZE=atoi(optarg);`
252	32	alirezamon	`break;`
253	38	alirezamon	`case 'm':`
254			`MAX_PACKET_SIZE=atoi(optarg);`
255			`break;`
256	32	alirezamon	`case 'n':`
257			`MAX_PCK_NUM=atoi(optarg);`
258			`break;`
259			`case 'c':`
260			`MAX_SIM_CLKs=atoi(optarg);`
261			`break;`
262	38	alirezamon	`case 'i':`
263			`f=atof(optarg);`
264			`f*=(MAX_RATIO/100);`
265			`ratio= (int) f;`
266	32	alirezamon	`break;`
267			`case 'p':`
268			`p= parse_string (optarg, array);`
269			`C0_p=array[0];`
270			`C1_p=array[1];`
271			`C2_p=array[2];`
272			`C3_p=array[3];`
273			`break;`
274	38	alirezamon
275	32	alirezamon	`case 'h':`
276	38	alirezamon
277			`update_hotspot(optarg);`
278
279	32	alirezamon
280			`break;`
281
282
283
284			`case '?':`
285			`if (isprint (optopt))`
286			fprintf (stderr, "Unknown option `-%c'.\n", optopt);
287			`else`
288			`fprintf (stderr,`
289			"Unknown option character `\\x%x'.\n",
290			`optopt);`
291			`default:`
292			`usage();`
293			`exit(1);`
294			`}`
295			`}`
296	38	alirezamon	`PACKET_SIZE=(MIN_PACKET_SIZE+MAX_PACKET_SIZE)/2;// average packet size`
297	32	alirezamon	`}`
298
299
300			`int main(int argc, char** argv) {`
301			`char change_injection_ratio=0,inject_done;`
302			`int i,j,x,y;//,report_delay_counter=0;`
303			`char file_name[100];`
304			`char deafult_out[] = {"result"};`
305			`char * out_file_name;`
306			`unsigned int dest_x, dest_y;`
307			`int flit_out_all_size = sizeof(router[0]->flit_out_all)/sizeof(router[0]->flit_out_all[0]);`
308			`while((0x1<<Xw) < NX)Xw++; //log2`
309			`while((0x1<<Yw) < NY)Yw++;`
310
311
312			`Verilated::commandArgs(argc, argv); // Remember args`
313
314			`for(i=0;i<NC;i++) router[i] = new Vrouter; // Create instance`
315			`noc = new Vnoc;`
316			`for(i=0;i<NC;i++) traffic[i] = new Vtraffic;`
317	38	alirezamon
318			`processArgs ( argc, argv );`
319
320
321			`FIXED_SRC_DST_PAIR = strcmp (TRAFFIC,"RANDOM") & strcmp(TRAFFIC,"HOTSPOT") & strcmp(TRAFFIC,"random") & strcmp(TRAFFIC,"hot spot") & strcmp(TRAFFIC,"CUSTOM from file");`
322
323	32	alirezamon
324			`/********************`
325			`* initialize input`
326			`*********************/`
327
328			`reset=1;`
329			`reset_all_register();`
330			`noc->start_i=0;`
331	38	alirezamon
332	32	alirezamon
333			`for(x=0;x<NX;x++)for(y=0;y<NY;y++){`
334	38	alirezamon
335	32	alirezamon	`i=(y*NX)+x;`
336	38	alirezamon	`random_var[i] = 100;`
337	32	alirezamon	`router[i]->current_x = x;`
338			`router[i]->current_y = y;`
339			`traffic[i]->current_x = x;`
340			`traffic[i]->current_y = y;`
341			`traffic[i]->start=0;`
342			`traffic[i]->pck_class_in= pck_class_in_gen( i);`
343			`pck_dst_gen ( x,y,i, &dest_x, &dest_y);`
344			`traffic[i]->dest_x= dest_x;`
345			`traffic[i]->dest_y=dest_y;`
346	38	alirezamon	`traffic[i]->stop=0;`
347			`if(TRAFFIC_TYPE==SYNTHETIC){`
348			`traffic[i]->pck_size_in=PACKET_SIZE;`
349			`traffic[i]->avg_pck_size_in=PACKET_SIZE;`
350			`traffic[i]->ratio=ratio;`
351			`traffic[i]->init_weight=1;`
352			`}`
353	32	alirezamon
354	38	alirezamon
355	32	alirezamon	`}`
356	38	alirezamon	`//traffic[35]->init_weight=10;`
357	32	alirezamon
358	38	alirezamon
359	32	alirezamon
360			`main_time=0;`
361			`print_parameter();`
362	38	alirezamon	`if(strcmp(TRAFFIC,"CUSTOM from file")) printf("\n\n\n Flit injection ratio per router is =%f \n",(float)ratio*100/MAX_RATIO);`
363	32	alirezamon	`//printf("\n\n\n delay= %u clk",router->delay);`
364			`while (!Verilated::gotFinish()) {`
365
366			`if (main_time-saved_time >= 10 ) {`
367			`reset = 0;`
368			`}`
369
370			`if(main_time == saved_time+21){ count_en=1; noc->start_i=1;}//for(i=0;i<NC;i++) traffic[i]->start=1;}`
371			`if(main_time == saved_time+26) noc->start_i=0;// for(i=0;i<NC;i++) traffic[i]->start=0;`
372	38	alirezamon
373			`if ((main_time % 4) == 0) {`
374	32	alirezamon	`clk = 1; // Toggle clock`
375			`if(count_en) clk_counter++;`
376	38	alirezamon	`inject_done= ((total_pck_num >= MAX_PCK_NUM) \|\| (clk_counter>= MAX_SIM_CLKs) \|\| total_active_routers == 0);`
377	32	alirezamon	`//if(inject_done) printf("clk_counter=========%d\n",clk_counter);`
378	38	alirezamon	`for(y=0;y<NY;y++)for(x=0;x<NX;x++)`
379	32	alirezamon	`{`
380			`i=(y*NX)+x;`
381			`// a packet has been received`
382			`if(traffic[i]->update & ~reset){`
383	38	alirezamon	`update_noc_statistic (i) ;`
384
385	32	alirezamon	`}`
386			`// the header flit has been sent out`
387			`if(traffic[i]->hdr_flit_sent ){`
388			`traffic[i]->pck_class_in= pck_class_in_gen( i);`
389	38	alirezamon	`sent_core_total_pck_num[i]++;`
390	32	alirezamon	`if(!FIXED_SRC_DST_PAIR){`
391			`pck_dst_gen ( x,y,i, &dest_x, &dest_y);`
392			`traffic[i]->dest_x= dest_x;`
393			`traffic[i]->dest_y=dest_y;`
394			`}`
395			`}`
396
397			`if(traffic[i]->flit_out_wr==1) flit_counter++;`
398
399			`}//for`
400			`if(inject_done) {`
401			`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;`
402
403			`printf(" simulation clock cycles:%d\n",clk_counter);`
404			`printf(" total received flits:%d\n",flit_counter);`
405			`print_statistic(out_file_name);`
406			`change_injection_ratio = 1;`
407			`for(i=0;i<NC;i++) {`
408			`router[i]->final();`
409			`traffic[i]->final();`
410			`}`
411	38	alirezamon	`noc->final();`
412	32	alirezamon	`return 0;`
413			`}`
414
415
416
417			`}//if`
418			`else`
419			`{`
420
421			`clk = 0;`
422	41	alirezamon	`#if (NC<=64)`
423	32	alirezamon	`noc->ni_flit_in_wr =0;`
424	41	alirezamon	`#else`
425			`for(j=0;j<(sizeof(noc->ni_flit_in_wr)/sizeof(noc->ni_flit_in_wr[0])); j++) noc->ni_flit_in_wr[j]=0;`
426			`#endif`
427	32	alirezamon	`for(x=0;x<NX;x++)for(y=0;y<NY;y++){`
428			`i=(y*NX)+x;`
429
430
431			`router[i]->flit_in_we_all = noc->router_flit_out_we_all[i];`
432			`router[i]->credit_in_all = noc->router_credit_out_all[i];`
433			`router[i]->congestion_in_all = noc->router_congestion_out_all[i];`
434	38	alirezamon	`//router[i]->iport_weight_in_all = noc->router_iport_weight_out_all[i];`
435
436	32	alirezamon	`for(j=0;j<flit_out_all_size;j++)router[i]->flit_in_all[j] = noc->router_flit_out_all[i][j];`
437
438
439			`noc->router_flit_in_we_all[i] = router[i]->flit_out_we_all ;`
440			`noc->router_credit_in_all[i] = router[i]->credit_out_all;`
441			`noc->router_congestion_in_all[i]= router[i]->congestion_out_all;`
442	38	alirezamon	`//noc->router_iport_weight_in_all[i]= router[i]->iport_weight_out_all;`
443
444	32	alirezamon	`for(j=0;j<flit_out_all_size;j++) noc->router_flit_in_all[i][j] = router[i]->flit_out_all[j] ;`
445	41	alirezamon	`#if (Fpay<=32)`
446	32	alirezamon	`traffic[i]->flit_in = noc->ni_flit_out [i];`
447	41	alirezamon	`#else`
448			`for(j=0;j<(sizeof(traffic[i]->flit_out)/sizeof(traffic[i]->flit_out[0])); j++) traffic[i]->flit_in[j] = noc->ni_flit_out [i][j];`
449			`#endif`
450	32	alirezamon	`traffic[i]->credit_in= noc->ni_credit_out[i];`
451
452
453			`noc->ni_credit_in[i] = traffic[i]->credit_out;`
454	41	alirezamon	`#if (Fpay<=32)`
455	32	alirezamon	`noc->ni_flit_in [i] = traffic[i]->flit_out;`
456	41	alirezamon	`#else`
457			`for(j=0;j<(sizeof(traffic[i]->flit_out)/sizeof(traffic[i]->flit_out[0])); j++) noc->ni_flit_in [i][j] = traffic[i]->flit_out[j];`
458			`#endif`
459	32	alirezamon
460	41	alirezamon	`#if (NC<=64)`
461	32	alirezamon	`if(traffic[i]->flit_out_wr) noc->ni_flit_in_wr = noc->ni_flit_in_wr \| ((vluint64_t)1<<i);`
462			`traffic[i]->flit_in_wr= ((noc->ni_flit_out_wr >> i) & 0x01);`
463	41	alirezamon	`#else`
464			`if(traffic[i]->flit_out_wr) MY_VL_SETBIT_W(noc->ni_flit_in_wr ,i);`
465			`traffic[i]->flit_in_wr= (VL_BITISSET_W(noc->ni_flit_out_wr,i)>0);`
466			`#endif`
467
468	32	alirezamon
469
470			`}//for`
471
472
473			`}//else`
474			`//if(main_time > 20 && main_time < 30 ) traffic->start=1; else traffic->start=0;`
475			`//if(main_time == saved_time+25) router[0]->flit_in_we_all=0;`
476			`//if((main_time % 250)==0) printf("router->all_done =%u\n",router->all_done);`
477
478
479			`noc-> clk = clk;`
480			`noc-> reset = reset;`
481
482
483			`for(i=0;i<NC;i++) {`
484	41	alirezamon	`#if (NC<=64)`
485	32	alirezamon	`traffic[i]->start= ((noc->start_o >>i)& 0x01);`
486	41	alirezamon	`#else`
487			`traffic[i]->start= (VL_BITISSET_W(noc->start_o, i)>0);`
488			`#endif`
489	32	alirezamon	`traffic[i]->reset= reset;`
490			`traffic[i]->clk = clk;`
491			`router[i]->reset= reset;`
492			`router[i]->clk= clk ;`
493
494			`}`
495
496
497			`noc->eval();`
498
499
500			`for(i=0;i<NC;i++) {`

Browse

Tools

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

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [src_verilator/] [simulator.cpp] - Blame information for rev 42