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

#! /usr/bin/perl -w

use constant::boolean;

use strict;

use warnings;

use FindBin;

use lib $FindBin::Bin;

use GD::Graph::Data;

use emulator;

use GD::Graph::colour qw/:colours/;

use File::Basename;

use File::Path qw/make_path/;

use File::Copy;

use File::Find::Rule;

require "widget.pl";

require "mpsoc_gen.pl";

require "emulator.pl";

require "mpsoc_verilog_gen.pl";

require "readme_gen.pl";

require "graph.pl";

use List::MoreUtils qw(uniq);

sub generate_sim_bin_file {

        my ($simulate,$info_text) =@_;

        #check simulator envirement

        my $simulator =$simulate->object_get_attribute("Simulator");

        #TODO generate .sim file only for modelsim simulator

        $simulate->object_add_attribute('status',undef,'run');

        set_gui_status($simulate,"ref",1);

        my ($nr,$ne,$router_p,$ref_tops,$includ_h)= get_noc_verilator_top_modules_info($simulate);

        my %tops = %{$ref_tops};

        $tops{Vtraffic} = "--top-module traffic_gen_top";

        $tops{Vpck_inj} = "--top-module packet_injector_verilator";

        my $target_dir= "$ENV{PRONOC_WORK}/simulate";

        my $project_dir   = get_project_dir()."/mpsoc/";

        my $src_verilator_dir="$project_dir/src_verilator";

        my $src_c="$project_dir/src_c";

        my $src_noc_dir="$project_dir/rtl/src_noc";

        my $script_dir="$project_dir/script";

        my $testbench_file= "$src_verilator_dir/simulator.cpp";

        my $target_verilog_dr ="$target_dir/src_verilog";

        my $obj_dir ="$target_dir/verilator/obj_dir/";

        rmtree("$target_dir/verilator");

        rmtree("$target_verilog_dr");

        mkpath("$target_verilog_dr/",1,01777);

        #copy src_verilator files

        my @files_list = File::Find::Rule->file()

                            ->name( '*.v','*.V','*.sv' )

                            ->in( "$src_verilator_dir" );

        #make sure source files have key word 'module' 

        my @files;

        foreach my $p (@files_list){

                push (@files,$p)        if(check_file_has_string($p,'module'));

        }

        push (@files,$src_noc_dir);

        push (@files,"$project_dir/rtl/arbiter.v");

        push (@files,"$project_dir/rtl/main_comp.v");

        push (@files,"$project_dir/rtl/pronoc_def.v");

        #my @files=(

        #       $src_noc_dir,

        #       "$src_verilator_dir/noc_connection.sv",

        #       "$src_verilator_dir/mesh_torus_noc_connection.sv",                      

        #       "$src_verilator_dir/router_verilator.v",

        #       "$src_verilator_dir/traffic_gen_verilator.v"            

        #);

        copy_file_and_folders (\@files,$project_dir,$target_verilog_dr);

        copy_file_and_folders (\@files,$project_dir,"$target_dir/modelsim/src_verilog/");

        my $target_modelsim_dr ="$target_dir/modelsim/src_modelsim";

        my $src_modelsim_dir="$project_dir/rtl/src_modelsim";

        rmtree("$target_modelsim_dr");

        mkpath("$target_modelsim_dr/",1,01777);

        #copy src_verilator files

        @files_list = File::Find::Rule->file()

                            ->name( '*.v','*.V','*.sv' )

                            ->in( "$src_modelsim_dir" );

        #make sure source files have key word 'module' 

        @files=();

        foreach my $p (@files_list){

                push (@files,$p)        if(check_file_has_string($p,'module'));

        }

        copy_file_and_folders (\@files,$project_dir,$target_modelsim_dr);

        #check if we have a custom topology 

        my $topology=$simulate->object_get_attribute('noc_param','TOPOLOGY');

        if ($topology eq '"CUSTOM"'){

                my $name=$simulate->object_get_attribute('noc_param','CUSTOM_TOPOLOGY_NAME');

                $name=~s/["]//gs;

                my $dir1=  get_project_dir()."/mpsoc/rtl/src_topolgy/$name";

                my $dir2=  get_project_dir()."/mpsoc/rtl/src_topolgy/common";

                my @files = File::Find::Rule->file()

                            ->name( '*.v','*.V','*.sv' )

                            ->in( "$dir1" );

                copy_file_and_folders (\@files,$project_dir,$target_verilog_dr);

                copy_file_and_folders (\@files,$project_dir,"$target_dir/modelsim/src_verilog/");

                @files = File::Find::Rule->file()

                            ->name( '*.v','*.V','*.sv' )

                            ->in( "$dir2" );

                copy_file_and_folders (\@files,$project_dir,$target_verilog_dr);

                copy_file_and_folders (\@files,$project_dir,"$target_dir/modelsim/src_verilog/");

        }

        # generate NoC parameter file

        #my ($noc_param,$pass_param)=gen_noc_param_v($simulate);

        #open(FILE,  ">$target_verilog_dr/parameter.v") || die "Can not open: $!";

        my $fifow=$simulate->object_get_attribute('fpga_param','TIMSTMP_FIFO_NUM');

        gen_noc_localparam_v_file($simulate,"$target_verilog_dr/src_noc");

        #generate routers with different port num

        my $cpu_num = $simulate->object_get_attribute('compile', 'cpu_num');

        my $result = verilator_compilation (\%tops,$target_dir,$info_text,$cpu_num);

        if ($result){

                add_colored_info($info_text,"Veriator model has been generated successfully!\n",'blue');

        }else {

                add_colored_info($info_text,"Verilator compilation failed!\n","red");

                $simulate->object_add_attribute('status',undef,'programmer_failed');

                set_gui_status($simulate,"ref",1);

                print "gen-ended!\n";

                return;

        }

        my $r;

        #copy nettrace synful

        dircopy("$src_c/netrace-1.0","$obj_dir/netrace-1.0") or $r=$!;

        dircopy("$src_c/synfull","$obj_dir/synful") or $r=$!;

        add_colored_info($info_text,"ERROR: $r\n","red") if(defined $r ) ;

        #copy simulation c header files

        @files = File::Find::Rule->file()

                            ->name( '*.h')

                            ->in( "$src_verilator_dir" );

        copy_file_and_folders (\@files,$project_dir,$obj_dir);

        copy($testbench_file,"$obj_dir/testbench.cpp");

        #compile the testbench

        my $param_h=gen_noc_param_h($simulate);

        my $text = gen_sim_parameter_h($param_h,$includ_h,$ne,$nr,$router_p,$fifow);

        open(FILE,  ">$obj_dir/parameter.h") || die "Can not open: $!";

        print FILE  "$text";

        close FILE;

        #$result = run_make_file("$obj_dir/",$info_text,'lib');

        my $lib_num=0;

        add_colored_info($info_text,"Makefie will use the maximum number of $cpu_num core(s) in parallel for compilation\n",'green');

        my $length=scalar (keys %tops);

        my $cmd="";

        foreach my $top (sort keys %tops) {

                $cmd.= "lib$lib_num & ";

                $lib_num++;

                if( $lib_num % $cpu_num == 0 || $lib_num == $length){

                        $cmd.="wait\n";

                        $result = run_make_file("$obj_dir/",$info_text,$cmd);

                        if ($result ==0){

                                $simulate->object_add_attribute('status',undef,'programmer_failed');

                                set_gui_status($simulate,"ref",1);

                                print "gen-ended!\n";

                                return;

                        }

                        $cmd="";

                }else {

                        $cmd.=" make ";

                }

        }

        run_make_file("$obj_dir/",$info_text);

        if ($result ==0){

                $simulate->object_add_attribute('status',undef,'programmer_failed');

                set_gui_status($simulate,"ref",1);

                print "gen-ended!\n";

                return;

        }

        #my $end = localtime;

        #save the binarry file

        my $bin= "$obj_dir/testbench";

        my $path=$simulate->object_get_attribute ('sim_param',"BIN_DIR");

        my $name=$simulate->object_get_attribute ('sim_param',"SAVE_NAME");

        #create project directory if it does not exist

        my      ($stdout,$exit)=run_cmd_in_back_ground_get_stdout("mkdir -p $path" );

        if($exit != 0 ){        print "$stdout\n";  print "gen-ended!\n";       message_dialog($stdout,'error'); return;}

        #check if the verilation was successful

        if ((-e $bin)==0) {#something goes wrong

        #message_dialog("Verilator compilation was unsuccessful please check the $path/$name.log files for more information",'error');

        add_colored_info($info_text,"Verilator compilation failed!\n","red");

        $simulate->object_add_attribute('status',undef,'programmer_failed');

                set_gui_status($simulate,"ref",1);

                print "gen-ended!\n";

                return;

        }

        #copy ($bin,"$path/$name") or  die "Can not copy: $!";

        ($stdout,$exit)=run_cmd_in_back_ground_get_stdout("cp -f $bin $path/$name");

        if($exit != 0 ){        print "$stdout\n";  print "gen-ended!\n";       message_dialog($stdout,'error'); return;}

        #save noc info

        open(FILE,  ">$path/$name.inf") || die "Can not open: $!";

        print FILE perl_file_header("$name.inf");

        my %pp;

        $pp{'noc_param'}= $simulate->{'noc_param'};

        $pp{'sim_param'}= $simulate->{'sim_param'};

        print FILE Data::Dumper->Dump([\%pp],["emulate_info"]);

        close(FILE) || die "Error closing file: $!";

        print "gen-ended successfully!\n";

        message_dialog("The simulation binary file has been successfully generated in $path!");

        $simulate->object_add_attribute('status',undef,'ideal');

        set_gui_status($simulate,"ref",1);

        #make project dir

        #my $dir= $simulate->object_get_attribute ("sim_param","BIN_DIR");

        #my $name=$simulate->object_get_attribute ("sim_param","SAVE_NAME");

        #my $path= "$dir/$name";

        #add_info($info_text, "$src_verilator_dir!\n");

        #mkpath("$path",1,01777);

}

##########

#       save_simulation

##########

sub save_simulation {

        my ($simulate)=@_;

        # read emulation name

        my $name=$simulate->object_get_attribute ("simulate_name",undef);

        my $s= (!defined $name)? 0 : (length($name)==0)? 0 :1;

        if ($s == 0){

                message_dialog("Please set Simulation name!");

                return 0;

        }

        # Write object file

        open(FILE,  ">lib/simulate/$name.SIM") || die "Can not open: $!";

        print FILE perl_file_header("$name.SIM");

        print FILE Data::Dumper->Dump([\%$simulate],["simulate"]);

        close(FILE) || die "Error closing file: $!";

        message_dialog("Simulation has saved as lib/simulate/$name.SIM!");

        return 1;

}

#############

#       load_simulation

############

sub load_simulation {

        my ($simulate,$info)=@_;

        my $file;

        my $dialog =  gen_file_dialog (undef, 'SIM');

        my $dir = Cwd::getcwd();

        $dialog->set_current_folder ("$dir/lib/simulate");

        if ( "ok" eq $dialog->run ) {

                $file = $dialog->get_filename;

                my ($name,$path,$suffix) = fileparse("$file",qr"\..[^.]*$");

                if($suffix eq '.SIM'){

                        my ($pp,$r,$err) = regen_object($file);

                        if ($r){

                                add_colored_info($info,"**Error reading $file file: $err\n",'red');

                                $dialog->destroy;

                                return;

                        }

                        #deactivate running simulations

                        $pp->object_add_attribute('status',undef,'ideal');

                        my @samples =$pp->object_get_attribute_order("samples");

                        foreach my $sample (@samples){

                                my $st=$pp->object_get_attribute ($sample,"status");

                                $pp->object_add_attribute ($sample,"status",'done');# if ($st eq "run");        

                        }

                        clone_obj($simulate,$pp);

                        #message_dialog("done!");                               

                }

     }

     $dialog->destroy;

}

sub check_hotspot_parameters{

        my ($self,$sample)=@_;

        my $num=$self->object_get_attribute($sample,"HOTSPOT_NUM");

        my $result;

        if (defined $num){

                my @hotspots;

                my $acuum=0;

                for (my $i=0;$i<$num;$i++){

                        my $w1 = $self->object_get_attribute($sample,"HOTSPOT_CORE_$i");

                        if( grep (/^\Q$w1\E$/,@hotspots)){

                                $result="Error: Tile $w1 has been selected for Two or more than two hotspot nodes.\n";

                        }

                        push( @hotspots,$w1);

                        my $w2 = $self->object_get_attribute($sample,"HOTSPOT_PERCENT_$i");

                        $acuum+=$w2;

                }

                if ($acuum > 100){

                        $result="Error: The traffic summation of all hotspot nodes is $acuum. The hotspot summation must be <=100";

                }

        }

        return $result;

}

sub get_district_avg {

        my ($self,$sample)=@_;

        my $vt=$self->object_get_attribute($sample,"DISCRETE_RANGE");

        $vt =  "2,3,4,5" unless (defined $vt);

        my $pt=$self->object_get_attribute($sample,"PROBEB_RANGE");

        $pt= "25,25,25,25" unless (defined $pt);

        my $avg=0;

        my @valus = split(',',$vt);

        my @probs = split(',',$pt);

        my $i=0;

        my $sum=0;

        my $min=10000000;

        my $max=0;

        foreach my $v (@valus) {

                return ("-","The $v is not numeric value") unless (is_integer($v));

                $sum+=  $probs[$i];

                $avg+=$v*$probs[$i];

                $i++;

                $min=$v if($min>$v);

                $max=$v if($max<$v);

        }

        return ("-","The summation of probebilities are $sum which is not equal 100.") if($sum!=100);

        $avg/=100;

        $self->object_add_attribute ($sample,"MIN_PCK_SIZE",$min);

        $self->object_add_attribute ($sample,"MAX_PCK_SIZE",$max);

        return ($avg,undef);

}

sub get_simulator_noc_configuration{

        my ($self,$mode,$sample,$set_win) =@_;

        my $table=def_table(10,2,FALSE);

        my $row=0;

        my $scrolled_win = add_widget_to_scrolled_win ($table,gen_scr_win_with_adjst($self,'noc_conf_scr_win'));

        my $ok = def_image_button('icons/select.png','_OK',FALSE,1);

        my $import   = def_image_button('icons/import.png','I_mport',FALSE,1);

        my $save   = def_image_button('icons/save.png','_Export',FALSE,1);

        $save ->signal_connect("clicked"=> sub{

                my $dialog=save_file_dialog  ("Enter configuration file name",'conf');

                #$dialog->set_current_folder ($open_in) if(defined  $open_in);

                if ( "ok" eq $dialog->run ) {

                        my      $file = $dialog->get_filename;

                        my ($name,$path,$suffix) = fileparse("$file",qr"\..[^.]*$");

                        my $t=$self->object_get_attribute($sample);

                        open(FILE,  ">$path/${name}.conf") || die "Can not open: $!";

                        print FILE Data::Dumper->Dump([\$t],['config']);

                        close FILE;

                }

                $dialog->destroy();

        });

        $import ->signal_connect("clicked"=> sub{

                my $dialog=save_file_dialog  ("Enter configuration file name",'conf');

                #$dialog->set_current_folder ($open_in) if(defined  $open_in);

                if ( "ok" eq $dialog->run ) {

                        my      $file = $dialog->get_filename;

                        my $pp= do $file ;

                    my $status=1;

                    $status=0 if $@;

                        message_dialog("Error reading: $@") if $@;

                        if ($status==1){

                                $self->object_add_attribute ("$sample",undef,$$pp);

                                set_gui_status($self,'ref_set_win',1);

                        }

                }

                $dialog->destroy();

        });

        my $mtable = def_table(10, 3, TRUE);

        $mtable->attach_defaults($scrolled_win,0,3,0,9);

        $mtable-> attach ($ok , 1, 2,  9, 10,'expand','shrink',2,2);

        $mtable-> attach ($import , 0, 1,  9, 10,'expand','shrink',2,2);

        $mtable-> attach ($save , 2, 3,  9, 10,'expand','shrink',2,2);

        $set_win ->signal_connect (destroy => sub{

                $self->object_add_attribute("active_setting",undef,undef);

        });

        my $dir = Cwd::getcwd();

        my $open_in       = abs_path("$ENV{PRONOC_WORK}/simulate");

        attach_widget_to_table ($table,$row,gen_label_in_left(" Search Path:"),gen_button_message ("Select the Path where the verilator simulation files are located. Different NoC verilated models can be generated using Generate NoC configuration tab.","icons/help.png"),

        get_dir_in_object ($self,$sample,"sof_path",undef,'ref_set_win',1,$open_in)); $row++;

        $open_in        = $self->object_get_attribute($sample,"sof_path");

        my @files = glob "$open_in/*";

        my $exe_files="";

        foreach my $file (@files){

                my ($name,$path,$suffix) = fileparse("$file",qr"\..[^.]*$");

                if($suffix eq '.inf'){

                        $exe_files="$exe_files,$name";

                }

        }

        my $model_obj = gen_combobox_object ($self,$sample, "sof_file", $exe_files, undef,'ref_set_win',1);

        attach_widget_to_table ($table,$row,gen_label_in_left(" Verilated Model:"),gen_button_message ("Select the verilator simulation file. Different NoC simulators can be generated using Generate NoC configuration tab.","icons/help.png"),

        $model_obj); $row++;

    my $cast_type=  '"UNICAST"';

    #get simulation parameters here                        

        my $s=$self->object_get_attribute($sample,"sof_file");

        if (defined $s){

                my ($infobox,$info)= create_txview();

                my $sof=get_sim_bin_path($self,$sample,$info);

                my ($name,$path,$suffix) = fileparse("$sof",qr"\..[^.]*$");

                my $sof_info= "$path$name.inf";

                my $pp= do $sof_info ;

                my $p=$pp->{'noc_param'};

                $cast_type = $p->{'CAST_TYPE'};

                $cast_type=  '"UNICAST"' if (!defined $cast_type);

        }

   my $trf_info = "Select of the following traffic models:

   1- Synthetic

   2- Task-graph :

       The task graph traffic pattern can be generated

       using ProNoC trace generator

   3- Netrace:

       Dependency-Tracking Trace-Based Network-on-Chip

       Simulation. For downloading the trace files and more

       information refere to https://www.cs.utexas.edu/~netrace/

   4- SynFull:

       Synthetic Traffic Models Capturing a Full Range

       of Cache Coherent Behaviour

       https://github.com/mariobadr/synfull-isca

";

    my $coltmp=0;

    ($row,$coltmp)=add_param_widget  ($self, "Traffic Type", "TRAFFIC_TYPE", "Synthetic", 'Combo-box', "Synthetic,Task-graph,SynFull,Netrace", $trf_info, $table,$row,undef,1, $sample, 1,'ref_set_win');

    my $traffictype=$self->object_get_attribute($sample,"TRAFFIC_TYPE");

    my $MIN_PCK_SIZE=$self->object_get_attribute($sample,"MIN_PCK_SIZE");

   my $max_pck_num = get_MAX_PCK_NUM();

   my $max_sim_clk = get_MAX_SIM_CLKs();

   my $pck_info = "Select how injected packet size are selected.

                random-range:    The injected packet size is randomly selected between given minimum and maximum packet size.

                random-discrete: The injected packet size is randomly selected among given district valuse.";

        if($traffictype eq "Synthetic"){

                my $min=$self->object_get_attribute($sample,'MIN_PCK_SIZE');

                my $max=$self->object_get_attribute($sample,'MAX_PCK_SIZE');

                $min=5 if(!defined $min);

                $max=5 if(!defined $max);

                $max= $min if($max< $min);

                my $avg=floor(($min+$max)/2);

                my $msg;

                my $max_pck_size =       get_MAX_PCK_SIZ();

                my $NE;

                my ($infobox,$info)= create_txview();

                my $traffics="tornado,transposed 1,transposed 2,bit reverse,bit complement,random,hot spot,shuffle,bit rotation,neighbor,custom";

                my @synthinfo = (

                { label=>'Configuration name:', param_name=>'line_name', type=>'Entry', default_val=>$sample, content=>undef, info=>"NoC configuration name. This name will be shown in load-latency graph for this configuration", param_parent=>$sample, ref_delay=> undef, new_status=>undef},

                { label=>"Total packet number limit:", param_name=>'PCK_NUM_LIMIT', type=>'Spin-button', default_val=>200000, content=>"2,$max_pck_num,1", info=>"Simulation will stop when total number of sent packets by all nodes reaches packet number limit  or total simulation clock reach its limit", param_parent=>$sample, ref_delay=>undef, new_status=>undef},

                { label=>"Simulator clocks limit:", param_name=>'SIM_CLOCK_LIMIT', type=>'Spin-button', default_val=>100000, content=>"2,$max_sim_clk,1", info=>"Each node stops sending packets when it reaches packet number limit  or simulation clock number limit", param_parent=>$sample, ref_delay=>undef,  new_status=>undef},

                { label=>"Traffic name", param_name=>'traffic', type=>'Combo-box', default_val=>'random', content=>$traffics, info=>"Select traffic pattern", param_parent=>$sample, ref_delay=>1, new_status=>'ref_set_win'},

                { label=>"Packet size (#flit)", param_name=>'PCK_SIZ_SEL', type=>'Combo-box', default_val=>'random-range', content=>"random-range,random-discrete", info=>$pck_info, param_parent=>$sample, ref_delay=>1, new_status=>'ref_set_win'},

                );

                my $coltmp=0;

                foreach my $d (@synthinfo) {

                        ($row,$coltmp)=add_param_widget ($self, $d->{label}, $d->{param_name}, $d->{default_val}, $d->{type}, $d->{content}, $d->{info}, $table,$row,undef,1, $d->{param_parent}, $d->{ref_delay}, $d->{new_status});

                }

                my $t=$self->object_get_attribute($sample,"PCK_SIZ_SEL");

                if($t eq 'random-range' ){

                        @synthinfo = (

                        { label=>"Min pck size :", param_name=>'MIN_PCK_SIZE', type=>'Spin-button', default_val=>5, content=>"1,$max,1", info=>"Minimum packet size in flit. The injected packet size is randomly selected between minimum and maximum packet size", param_parent=>$sample, ref_delay=>10, new_status=>'ref_set_win'},

                        { label=>"Max pck size :", param_name=>'MAX_PCK_SIZE', type=>'Spin-button', default_val=>5, content=>"$min,$max_pck_size,1", info=>"Maximum packet size in flit. The injected packet size is randomly selected between minimum and maximum packet size", param_parent=>$sample, ref_delay=>10, new_status=>'ref_set_win'},

                        { label=>"Avg. Packet size:", param_name=>'PCK_SIZE', type=>'Fixed', default_val=>$avg, content=>"$avg", info=>undef, param_parent=>$sample, ref_delay=>undef},

                        );

                }else{

                        #$self->object_add_attribute ($sample,"MIN_PCK_SIZE",2);#will be updated by get_district_avg  

                        my $vt=$self->object_get_attribute($sample,"DISCRETE_RANGE");

                        $vt =  "2,3,4,5" unless (defined $vt);

                        my $pt=$self->object_get_attribute($sample,"PROBEB_RANGE");