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

#! /usr/bin/perl -w

use Glib qw/TRUE FALSE/;

use strict;

use warnings;

use Gtk2;

use Gtk2::Ex::Graph::GD;

use GD::Graph::Data;

use emulator;

use IO::CaptureOutput qw(capture qxx qxy);

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

use Proc::Background;

use Time::HiRes qw( usleep ualarm gettimeofday tv_interval nanosleep  clock_gettime clock_getres clock_nanosleep clock stat );

use File::Basename;

use File::Path qw/make_path/;

use File::Copy;

use File::Find::Rule;

require "widget.pl";

require "emulate_ram_gen.pl";

require "mpsoc_gen.pl";

require "mpsoc_verilog_gen.pl";

require "readme_gen.pl";

use List::MoreUtils qw(uniq);

# hardware parameters taken from noc_emulator.v

use constant PCK_CNTw =>30;  # packet counter width in bits (results in maximum of 2^30 = 1  G packets)

use constant PCK_SIZw =>14;  # packet size width in bits (results in maximum packet size of 2^14 = 16 K flit)

use constant MAXXw    =>4;   # maximum nodes in x dimention is 2^MAXXw equal to 16 nodes in x dimention

use constant MAXYw    =>4;   # 16 nodes in y dimention : hence max emulator size is 16X16

use constant MAXCw    =>4;   # 16 message classes  

use constant RATIOw   =>7;   # log2(100)

use constant MAX_PATTERN => 124;

use constant RAM_SIZE => (MAX_PATTERN+4);

#use constant MAX_PCK_NUM => (2**PCK_CNTw)-1;

use constant MAX_PCK_NUM => (2**PCK_CNTw)-1;

use constant MAX_PCK_SIZ => (2**PCK_SIZw)-1;

use constant MAX_SIM_CLKs=> 100000000; # simulation end at if clock counter reach this number           

use constant EMULATION_RTLS => "/mpsoc/src_emulate/rtl/noc_emulator.v , /mpsoc/src_peripheral/jtag/jtag_wb/ , /mpsoc/src_peripheral/ram/generic_ram.v, /mpsoc/src_noc/";

sub gen_chart {

        my $emulate=shift;

        my($width,$hight)=max_win_size();

        my $graph_w=$width/2.5;

        my $graph_h=$hight/2.5;

        my $graph = Gtk2::Ex::Graph::GD->new($graph_w, $graph_h, 'linespoints');

        my @x;

        my @legend_keys;

        my $sample_num=$emulate->object_get_attribute("emulate_num",undef);

        my $scale= $emulate->object_get_attribute("graph_scale",undef);

        my @results;

        $results[0]=[0];

        $results[1]= [0];

my $legend_info="This attribute controls placement of the legend within the graph image. The value is supplied as a two-letter string, where the first letter is placement (a B or an R for bottom or right, respectively) and the second is alignment (L, R, C, T, or B for left, right, center, top, or bottom, respectively). ";

my @ginfo = (

{ label=>"Graph Title", param_name=>"G_Title", type=>"Entry", default_val=>undef, content=>undef, info=>undef, param_parent=>'graph_param', ref_delay=>undef },

{ label=>"Y Axix Title", param_name=>"Y_Title", type=>"Entry", default_val=>'Latency (clock)', content=>undef, info=>undef, param_parent=>'graph_param', ref_delay=>undef },

  { label=>"X Axix Title", param_name=>"X_Title", type=>"Entry", default_val=>'Load per router (flits/clock (%))', content=>undef, info=>undef, param_parent=>'graph_param',ref_delay=>undef },

  { label=>"legend placement", param_name=>"legend_placement", type=>'Combo-box', default_val=>'BL', content=>"BL,BC,BR,RT,RC,RB", info=>$legend_info, param_parent=>'graph_param', ref_delay=>undef},

 { label=>"Y min", param_name=>"Y_MIN", type=>'Spin-button', default_val=>0, content=>"0,1024,1", info=>"Y axix minimum value", param_parent=>'graph_param', ref_delay=> 5},

 { label=>"X min", param_name=>"X_MIN", type=>'Spin-button', default_val=>0, content=>"0,1024,1", info=>"X axix minimum value", param_parent=>'graph_param', ref_delay=> 5},

{ label=>"X max", param_name=>"X_MAX", type=>'Spin-button', default_val=>100, content=>"0,1024,1", info=>"X axix maximum value", param_parent=>'graph_param', ref_delay=> 5},

 { label=>"Line Width", param_name=>"LINEw", type=>'Spin-button', default_val=>3, content=>"1,20,1", info=>undef, param_parent=>'graph_param', ref_delay=> 5},

);

        if(defined  $sample_num){

                my @color;

                my $min_y=200;

                for (my $i=1;$i<=$sample_num; $i++) {

                        my $color_num=$emulate->object_get_attribute("sample$i","color");

                        my $l_name= $emulate->object_get_attribute("sample$i","line_name");

                        $legend_keys[$i-1]= (defined $l_name)? $l_name : "NoC$i";

                        $color_num=$i+1 if(!defined $color_num);

                        push(@color, "my_color$color_num");

                        my $ref=$emulate->object_get_attribute ("sample$i","result");

                        if(defined $ref) {

                                push(@x, sort {$a<=>$b} keys $ref);

                        }

                }#for

        my  @x2;

        @x2 =  uniq(sort {$a<=>$b} @x) if (scalar @x);

        my  @x1; #remove x values larger than x_max

        my $x_max= $emulate->object_get_attribute( 'graph_param','X_MAX');

        foreach  my $p (@x2){

                if(defined $x_max) {push (@x1,$p) if($p<$x_max);}

                else {push (@x1,$p);}

        }

        #print "\@x1=@x1\n";

        if (scalar @x1){

                $results[0]=\@x1;

                my $i;

                for ($i=1;$i<=$sample_num; $i++) {

                        my $j=0;

                        my $ref=$emulate->object_get_attribute ("sample$i","result");

                        if(defined $ref){

                                #print "$i\n";

                                my %line=%$ref;

                                foreach my $k (@x1){

                                        $results[$i][$j]=$line{$k};

                                        $min_y= $line{$k} if (defined $line{$k} && $line{$k}!=0 && $min_y > $line{$k});

                                        $j++;

                                }#$k

                        }#if

                        else {

                                $results[$i][$j]=undef;

                        }

                }#$i

        }#if

        my $max_y=$min_y*$scale;

        my $s=scalar @x1;

        # all results which is larger than ymax will be changed to ymax,

        for (my $i=1;$i<=$sample_num; $i++) {

                for (my $j=1;$j<=$s; $j++) {

                        $results[$i][$j]=($results[$i][$j]>$max_y)? $max_y: $results[$i][$j] if (defined $results[$i][$j]);

                }

        }

        my $graphs_info;

        foreach my $d ( @ginfo){

                $graphs_info->{$d->{param_name}}=$emulate->object_get_attribute( 'graph_param',$d->{param_name});

                $graphs_info->{$d->{param_name}}= $d->{default_val} if(!defined $graphs_info->{$d->{param_name}});

        }

        $graph->set (

                x_label         => $graphs_info->{X_Title},

                y_label         => $graphs_info->{Y_Title},

                y_max_value     => $max_y,

                y_min_value     => $graphs_info->{Y_MIN},

                y_tick_number   => 8,

               #        x_min_value     => $graphs_info->{X_MIN}, # dosent work?

                title           => $graphs_info->{G_Title},

                bar_spacing     => 1,

                shadowclr       => 'dred',

                box_axis       => 0,

                skip_undef=> 1,

                transparent     => 1,

                                line_width              => $graphs_info->{LINEw},

                                cycle_clrs              => 'blue',

                                legend_placement => $graphs_info->{legend_placement},

                                dclrs=>\@color,

                );

     }#if

        $graph->set_legend(@legend_keys);

        my $data = GD::Graph::Data->new(\@results) or die GD::Graph::Data->error;

        $data->make_strict();

        my $image = my_get_image($emulate,$graph,$data);

      # print  Data::Dumper->Dump ([\@results],['ttt']); 

        my $table = Gtk2::Table->new (25, 10, FALSE);

                my $box = Gtk2::HBox->new (TRUE, 2);

                my $filename;

                $box->set_border_width (4);

                my   $align = Gtk2::Alignment->new (0.5, 0.5, 0, 0);

                my $frame = Gtk2::Frame->new;

                $frame->set_shadow_type ('in');

                $frame->add ($image);

                $align->add ($frame);

                my $plus = def_image_button('icons/plus.png',undef,TRUE);

                my $minues = def_image_button('icons/minus.png',undef,TRUE);

                my $setting = def_image_button('icons/setting.png',undef,TRUE);

                my $save = def_image_button('icons/save.png',undef,TRUE);

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

                        $emulate->object_add_attribute("graph_scale",undef,$scale+0.5);

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

                });

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

                        $emulate->object_add_attribute("graph_scale",undef,$scale-0.5) if( $scale>0.5);

                        set_gui_status($emulate,"ref",5);

                });

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

                        get_graph_setting ($emulate,\@ginfo);

                });

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

                         my $G = $graph->{graph};

                         my @imags=$G->export_format();

                        save_graph_as ($emulate,\@imags);

                });

                $table->attach_defaults ($align , 0, 9, 0, 25);

                my $row=0;

                $table->attach ($plus , 9, 10, $row, $row+1,'shrink','shrink',2,2); $row++;

                $table->attach ($minues, 9, 10, $row, $row+1,'shrink','shrink',2,2); $row++;

                $table->attach ($setting, 9, 10, $row,  $row+1,'shrink','shrink',2,2); $row++;

                $table->attach ($save, 9, 10, $row,  $row+1,'shrink','shrink',2,2); $row++;

                while ($row<10){

                        my $tmp=gen_label_in_left('');

                        $table->attach_defaults ($tmp, 9, 10, $row,  $row+1);$row++;

                }

        return $table;

}

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

#       save_graph_as

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

sub save_graph_as {

        my ($emulate,$ref)=@_;

        my $file;

        my $title ='Save as';

        my @extensions=@$ref;

        my $open_in=undef;

        my $dialog = Gtk2::FileChooserDialog->new(

                'Save file', undef,

                'save',

                'gtk-cancel' => 'cancel',

                'gtk-ok'     => 'ok',

                );

        # if(defined $extension){

                foreach my $ext (@extensions){

                        my $filter = Gtk2::FileFilter->new();

                        $filter->set_name($ext);

                        $filter->add_pattern("*.$ext");

                        $dialog->add_filter ($filter);

                }

        # }

          if(defined  $open_in){

                $dialog->set_current_folder ($open_in);

                # print "$open_in\n";

        }

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

                        $file = $dialog->get_filename;

                        my $ext = $dialog->get_filter;

                        $ext=$ext->get_name;

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

                        $file = ($suffix eq ".$ext" )? $file : "$file.$ext";

                        $emulate->object_add_attribute("graph_save","name",$file);

                        $emulate->object_add_attribute("graph_save","extension",$ext);

                        $emulate->object_add_attribute("graph_save","save",1);

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

                         }

                        $dialog->destroy;

}

sub my_get_image {

        my ($emulate,$self, $data) = @_;

        $self->{graphdata} = $data;

        my $graph = $self->{graph};

        my $gd2=$graph->plot($data) or warn $graph->error;

        my $loader = Gtk2::Gdk::PixbufLoader->new;

        #cut the upper side of the image to remove the stright line created by chaanging large results to ymax

        my $gd1=  GD::Image->new($gd2->getBounds);

        my $white= $gd1->colorAllocate(255,255,254);

        my ($x,$h)=$gd2->getBounds;

        $gd1->transparent($white);

        $gd1->copy( $gd2, 0, 0, 0, ,$h*0.05, $x ,$h*.95 );

        $loader->write ($gd1->png);

        $loader->close;

        my $save=$emulate->object_get_attribute("graph_save","save");

        $save=0 if (!defined $save);

        if ($save ==1){

                my $file=$emulate->object_get_attribute("graph_save","name");

                my $ext=$emulate->object_get_attribute("graph_save","extension");

                $emulate->object_add_attribute("graph_save","save",0);

                #image

                open(my $out, '>', $file);

                if (tell $out )

                {

                        warn "Cannot open '$file' to write: $!";

                }else

                {

                        #my @extens=$graph->export_format();

                        binmode $out;

                        print $out $gd1->$ext;# if($ext eq 'png');

                        #print $out  $gd1->gif  if($ext eq 'gif');

                        close $out;

                }

                #text_file

                open(  $out, '>', "$file.txt");

                if (tell $out )

                {

                        warn "Cannot open $file.txt to write: $!";

                }

                else

                {

                        my $sample_num=$emulate->object_get_attribute("emulate_num",undef);

                        if (defined  $sample_num){

                                for (my $i=1;$i<=$sample_num; $i++) {

                                        my $l_name= $emulate->object_get_attribute("sample$i","line_name");

                                        my $ref=$emulate->object_get_attribute ("sample$i","result");

                                        my @x;

                                        if(defined $ref) {

                                                print $out "$l_name\n";

                                                foreach my $x (sort {$a<=>$b} keys $ref) {

                                                        my $y=$ref->{$x};

                                                        print $out "\t$x , $y\n";

                                                }

                                                print $out "\n\n";

                                        }

                                }#for

                        }

                        close $out;

                }

        }

        my $image = Gtk2::Image->new_from_pixbuf($loader->get_pixbuf);

        $self->{graphimage} = $image;

        my $hotspotlist;

        if ($self->{graphtype} eq 'bars' or

                $self->{graphtype} eq 'lines' or

                $self->{graphtype} eq 'linespoints') {

                foreach my $hotspot ($graph->get_hotspot) {

                        push @$hotspotlist, $hotspot if $hotspot;

                }

        }

        $self->{hotspotlist} = $hotspotlist;

        my $eventbox = $self->{eventbox};

        my @children = $eventbox->get_children;

        foreach my $child (@children) {

                $eventbox->remove($child);

        }

        $eventbox->add ($image);

        $eventbox->signal_connect ('button-press-event' =>

                sub {

                        my ($widget, $event) = @_;

                        return TRUE;

                        return FALSE unless $event->button == 3;

                        $self->{optionsmenu}->popup(

                                undef, # parent menu shell

                                undef, # parent menu item

                                undef, # menu pos func

                                undef, # data

                                $event->button,

                                $event->time

                        );

                }

        );

        $eventbox->show_all;

        return $eventbox;

}

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

#       get_graph_setting

###########

sub get_graph_setting {

        my ($emulate,$ref)=@_;

        my($width,$hight)=max_win_size();

        my $window=def_popwin_size($width/3,$hight/3,'Graph Setting');

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

        my $row=0;

my @data=@$ref;

foreach my $d (@data) {

        $row=noc_param_widget ($emulate, $d->{label}, $d->{param_name}, $d->{default_val}, $d->{type}, $d->{content}, $d->{info}, $table,$row,1, $d->{param_parent}, $d->{ref_delay});

}

        my $scrolled_win = new Gtk2::ScrolledWindow (undef, undef);

        $scrolled_win->set_policy( "automatic", "automatic" );

        $scrolled_win->add_with_viewport($table);

        my $ok = def_image_button('icons/select.png',' OK ');

        my $mtable = def_table(10, 1, FALSE);

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

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

        $window->add ($mtable);

        $window->show_all();

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

                $window->destroy;

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

        });

}

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

 # get_color_window

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

 sub get_color_window{

         my ($emulate,$atrebute1,$atrebute2)=@_;

         my $window=def_popwin_size(800,600,"Select line color");

         my ($r,$c)=(4,8);

         my $table= def_table(5,6,TRUE);

         for (my $col=0;$col<$c;$col++){

                  for (my $row=0;$row<$r;$row++){

                        my $color_num=$row*$c+$col;

                        my $color=def_colored_button("    ",$color_num);

                        $table->attach_defaults ($color, $col, $col+1, $row, $row+1);

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

                                $emulate->object_add_attribute($atrebute1,$atrebute2,$color_num);

                                #print "$emulate->object_add_attribute($atrebute1,$atrebute2,$color_num);\n";

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

                                $window->destroy;

                        });

                 }

         }

         $window->add($table);

        $window->show_all();

}

sub check_inserted_ratios {

                my $str=shift;

                my @ratios;

            my @chunks=split(',',$str);

            foreach my $p (@chunks){

                        if($p !~ /^[0-9.:,]+$/){ message_dialog ("$p has invalid character(S)" ); return undef; }

                        my @range=split(':',$p);

                        my $size= scalar @range;

                        if($size==1){ # its a number

                                if ( $range[0] <= 0 || $range[0] >100  ) { message_dialog ("$range[0] is out of boundery (1:100)" ); return undef; }