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

#!/usr/bin/perl -w

use strict;

use warnings;

use List::Util 'shuffle';

require "widget.pl";

use constant RESET_CMD          => " $ENV{'PRONOC_WORK'}/toolchain/bin/jtag_main -n 127 -d \"I:1,D:1:1,I:0\" ";

use constant UNRESET_CMD        => " $ENV{'PRONOC_WORK'}/toolchain/bin/jtag_main -n 127 -d \"I:1,D:1:0,I:0\" ";

use constant READ_DONE_CMD      => " $ENV{'PRONOC_WORK'}/toolchain/bin/jtag_main -n 127 -d \"I:2,R:1:0,I:0\" ";

use constant UPDATE_WB_ADDR     => 0x7;

use constant UPDATE_WB_WR_DATA  => 0x6;

use constant UPDATE_WB_RD_DATA  => 0x5;

use constant RD_WR_STATUS       => 0x4;

use constant PROBE_ST           => 0x2;

use constant SOURCE_ST          => 0x1;

use constant BYPAS_ST           => 0x0;

sub get_data{

        my ( $x, $y, $ref, $traffic, $ratio_in,$num, $line_num, $dest)=@_;

        my %noc_info= %$ref;

        my $C=$noc_info{C};

        my $xn=$noc_info{NX};

        my $yn=$noc_info{NY};

        my $MAX_PCK_NUM   = $noc_info{MAX_PCK_NUM};

        my $MAX_SIM_CLKs  = $noc_info{MAX_SIM_CLKs};

        my $MAX_PCK_SIZ   = $noc_info{MAX_PCK_SIZ};

        my $Xw          =   log2($xn);   # number of node in x axis

        my $Yw          =   log2($yn);   # number of node in y axis

        my $Cw          =  ($C > 1)? log2($C): 1;

        #$Fw          =   2+V+Fpay,

        my $RATIOw      =   log2(100),

        my $PCK_CNTw    =   log2($MAX_PCK_NUM+1),

        my $CLK_CNTw    =   log2($MAX_SIM_CLKs+1),

        my $PCK_SIZw    =   log2($MAX_PCK_SIZ+1);

        my $Dw=$PCK_CNTw+ $RATIOw + $PCK_SIZw + $Xw + $Yw + $Cw +1;

        my $val=0;

        my $q=0;

        my $i=0;

        my $last_adr=($traffic eq 'random' && $line_num<($xn* $yn)-2 )? 0 : 1;

        #print "my $last_adr=($traffic eq 'random' && $line_num<($xn* $yn)-2 )? 0 : 1; \n";

        my @fileds=get_ram_line($C, $x, $y, $xn, $yn, $traffic,$ratio_in,$line_num,$dest,$last_adr);

        my ($pck_num_to_send_,$ratio_in_,$pck_size_,$dest_x_,$dest_y_,$pck_class_in_,$last_adr_)=@fileds;

        my @sizes= ($PCK_CNTw, $RATIOw , $PCK_SIZw , $Xw , $Yw , $Cw ,1);

        foreach my $p (@fileds){

                $val= $val << $q;

                $val= $val + $p;

                $i++;

                $q=$sizes[$i] if(defined $sizes[$i]);

        }

        my $sum = 0;

        foreach my $num (@sizes){

                        $sum = $sum + $num;

        }

        my $result = sprintf("%010x", $val);

        #print"$result\n";      

        return ($result,$last_adr,$Dw);

#ram_do= {pck_num_to_send_,ratio_in_,pck_size_,dest_x_,dest_y_,pck_class_in_,last_adr_}; 

}

sub get_ram_line{

        my ($C, $x, $y, $xn, $yn, $traffic,$ratio_in,$line_num,$dest,$last_adr_)=@_;

        my $pck_num_to_send_=2000000;

        my $pck_size_=4;

        my $pck_class_in_=0;

        my $xw=log2($xn);

        my $yw=log2($yn);

        #print "$traffic\n";

        my $dest_x_;

        my $dest_y_;

        if( $traffic eq "transposed 1"){

                 $dest_x_= $xn-$y-1;

                 $dest_y_= $yn-$x-1;

        } elsif( $traffic eq "transposed 2"){

                $dest_x_  = $y;

                $dest_y_  = $x;

        } elsif( $traffic eq "bit reverse"){

                my $joint_addr= ($x << log2($xn))+$y;

                my $reverse_addr=0;

                my $pos=0;

                for(my $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));

         } elsif( $traffic  eq "bit complement") {

                 $dest_x_   = (~$x) &(0xFF>> (8-$xw));

                 $dest_y_   = (~$y) &(0xFF>> (8-$yw));

    }  elsif( $traffic eq "tornado") {

                #[(x+(k/2-1)) mod k, (y+(k/2-1)) mod k],

                 $dest_x_   = (($x + (($xn/2)-1))%$xn);

                 $dest_y_   = (($y + (($yn/2)-1))%$yn);

        } elsif( $traffic eq "random") {

                 #my $num=($y * $xn) +  $x;

                 $pck_num_to_send_=2;

                 $dest_x_   = $dest % $xn;

                 $dest_y_   = $dest  / $xn;

        }else{#off

                 print "***********************************$traffic is not defined*******************************************\n";

                 $dest_x_= $x;

                 $dest_y_= $y;

        }

        #print"  ($pck_num_to_send_,$ratio_in,$pck_size_,$dest_x_,$dest_y_,$pck_class_in_,$last_adr_);\n";

        return  ($pck_num_to_send_,$ratio_in,$pck_size_,$dest_x_,$dest_y_,$pck_class_in_,$last_adr_);

}

sub help {

                print

"       usage: ./ram_gen X  Y TRAFFIC

                X:  number of node in X direction 2<x<=16

                Y:  number of node in Y direction 2<y<=16

                TRAFFIC : select one of the following traffic patterns :

                        tornado,

                        transposed 1,

                        transposed 2,

                        random,

";

}

sub gen_ram{

        my ($data,$mem_width)=get_data(@_);

        my $result = sprintf("%8x", $data);

        return $result;

}

sub random_dest_gen {

        my $n=shift;

        my @c=(0..$n-1);

        my @o;

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

                my @l= shuffle @c;

                @l=remove_scolar_from_array(\@l,$i);

                $o[$i]=\@l;

        }

        return \@o;

}

sub run_cmd_update_info {

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

        my ($stdout,$exit,$stderr)=run_cmd_in_back_ground_get_stdout($cmd);

                if($exit){

                        add_info($info, "$stdout\n") if(defined $stdout);

                        add_info($info, "$stderr\n") if(defined $stderr);

                }

        return $exit;

}

sub programe_pck_gens{

        my ($ref, $traffic,$ratio_in,$info)= @_;

        my %noc_info= %$ref;

        my $C=$noc_info{C};

        my $xn=$noc_info{NX};

        my $yn=$noc_info{NY};

    #print( "@_\n" );

        my @traffics=("tornado", "transposed 1", "transposed 2", "bit reverse", "bit complement","random", "hot spot" );

        my $xc=$xn * $yn;

        my @randoms=@{random_dest_gen($xc)};

        if ( !defined $xn || $xn!~ /\s*\d+\b/ ){ add_info($info,"programe_pck_gens:invalid X value\n"); help(); return 0;}

        if ( !defined $yn || $yn!~ /\s*\d+\b/ ){ add_info($info,"programe_pck_gens:invalid Y value\n"); help(); return 0;}

        if ( !grep( /^$traffic$/, @traffics ) ){add_info($info,"programe_pck_gens:$traffic is an invalid Traffic name\n"); help(); return 0;}

        if ( $xn <2 || $xn >16 ){ add_info($info,"programe_pck_gens:invalid X value: ($xn). should be between 2 and 16 \n"); help(); return 0;}

        if ( $yn <2 || $yn >16 ){ add_info($info,"programe_pck_gens:invalid Y value:($yn). should be between 2 and 16 \n"); help(); return 0;}

        #reset the FPGA board   

        #run_cmd_in_back_ground("quartus_stp -t ./lib/tcl/mem.tcl reset");

        return if(run_cmd_update_info(RESET_CMD,$info));

my $argument='';

my $argument2='';

for (my $x=0; $x<$xn; $x=$x+1){

        for (my $y=0; $y<$yn; $y=$y+1){

                my $num=($y * $xn) +    $x;

                $num= ($num<=9)? "0$num" : $num;

                #add_info($info, "programe M$num\n");

                my $line=0;

                my ($ram_val,$end,$Dw);

                my $repeat=($traffic eq 'random')? "0x2710" : "0x0"; # 10000 : 0;

                $argument=undef;

                do{

                        ($ram_val,$end,$Dw)=get_data($x, $y, $ref, $traffic,$ratio_in,$num,$line,@{$randoms[$num]}[$line]);

                        if(!defined $argument ) { #first row

                                $argument="-n $num -d \"I:".UPDATE_WB_ADDR.",D:$Dw:0,I:".UPDATE_WB_WR_DATA.",D:$Dw:0x$ram_val";

                        }

                        #$argument="$argument M$num $line $ram_val";

                        else {

                                $argument=$argument.",D:$Dw:0x$ram_val";

                        }

                        #$argument="$argument M$num $line $ram_val";

                        $line++;

                        #print "\$line=$line\n";

                } while($end == 0);

                $argument=$argument.",I:0\"";

                #program the memory

                #print "$cmd\n";

                my $cmd="$ENV{'PRONOC_WORK'}/toolchain/bin/jtag_main $argument";

                return if(run_cmd_update_info ($cmd,$info));

                my $source_index=$num+128;

                $cmd= "$ENV{'PRONOC_WORK'}/toolchain/bin/jtag_main -n $source_index -d \"I:".SOURCE_ST.",D:100:$repeat,I:0\"";

                return if(run_cmd_update_info ($cmd,$info));

                #$argument2="$argument2 P$num $repeat";

                #my $file="./RAM/M$num.mif\n";

                #unless(open FILE, '>'.$file) { die "\nUnable to create $file\n";}

                # Write data to the file.

                #my $ram_content= gen_ram(0, $x, $y, $xn, $yn, $traffic,"M$num");

                #print FILE $ram_content;

                # close the file.

                #close FILE;

        }

}

#print "quartus_stp -t ./lib/tcl/mem.tcl $argument\n";

# ($result,$exit)=run_cmd_in_back_ground_get_stdout("quartus_stp -t ./lib/tcl/mem.tcl $argument");

#add_info($info,"update packet generators\n");

#print "($result,$exit)\n";

#return 0 if ($exit);

#print "quartus_stp -t ./lib/tcl/source.tcl $argument2\n";

#($result,$exit)=run_cmd_in_back_ground_get_stdout("quartus_stp -t ./lib/tcl/source.tcl $argument2");

#print "($result,$exit)\n";

#return 0 if ($exit);

# deassert the reset

        return if(run_cmd_update_info (UNRESET_CMD,$info));

#run_cmd_in_back_ground("quartus_stp -t ./lib/tcl/mem.tcl unreset");

#add_info($info,"$r\n");

return 1;

}

sub read_pack_gen{

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

        my %noc_info= %$ref;

        my $xn=$noc_info{NX};

        my $yn=$noc_info{NY};

#wait for done 

    add_info($info, "wait for done\n");

    my $done=0;

    my $counter=0;

    while ($done ==0){

                #my ($result,$exit) = run_cmd_in_back_ground_get_stdout("quartus_stp -t ./lib/tcl/read.tcl done");

                my ($result,$exit) = run_cmd_in_back_ground_get_stdout(READ_DONE_CMD);

                my @q =split  (/###read data#/,$result);

                #print "\$result=$result\n";

                $done=($q[1] eq "0x0")? 0 : 1;

                #print "\$q[1]=$q[1] done=$done\n";

                usleep(9000);

                $counter++;

                if($counter == 15){ # 

                        add_info($info,"Done is not asserted. I reset the board and try again\n");

                        return if(run_cmd_update_info (RESET_CMD,$info));

                        #run_cmd_in_back_ground("quartus_stp -t ./lib/tcl/mem.tcl reset");

                        usleep(300000);

                        return if(run_cmd_update_info (UNRESET_CMD,$info));

                        #run_cmd_in_back_ground("quartus_stp -t ./lib/tcl/mem.tcl unreset");                    

                }

                if($counter>30){

                          #something is wrong

                        add_info($info,"Done is not asserted again. I  am going to ignore this test case");

                        return undef;

                }

        }

        add_info($info,"Done is asserted\n");

        #my $i=0;

        my %results;

        my $sum_of_latency=0;

        my $sum_of_pck=0;

        for (my $x=0; $x<$xn; $x=$x+1){

                for (my $y=0; $y<$yn; $y=$y+1){

                        my $num=($y * $xn) +    $x;

                        my $source_index=$num+128;

                        my $cmd= "$ENV{'PRONOC_WORK'}/toolchain/bin/jtag_main -n $source_index -d \"I:".PROBE_ST.",R:100:0,I:0\"";

                        my ($result,$exit) = run_cmd_in_back_ground_get_stdout($cmd);

                        my @q =split  (/###read data#/,$result);

                my $d=$q[1];

                #print "num=$num:    ddddd=$d\n";       

                my $s= substr $d,2;

                #print "dddddddd=$s\n"; 

                my $latency =substr $s, 0,9;

                my $got_pck= substr $s, -16, 8;

                my $sent_pck= substr $s, -8;

                #print "$latency, $got_pck, $sent_pck\n";       

                $results{$num}{latency}=hex($latency);

                $results{$num}{got_pck}=hex($got_pck);

                $results{$num}{sent_pck}=hex($sent_pck);

                $sum_of_latency+=hex($latency);

                $sum_of_pck+=hex($got_pck);

                #$i=$i+2;

        }}

        foreach my $p (sort keys %results){

                #print "$p  : \n latency: $results{$p}{latency}\n";

                #print " got_pck : $results{$p}{got_pck}\n";

                #print "sent_pck:$results{$p}{sent_pck}\n\n";

        }

        my $avg= ($sum_of_pck>0)? $sum_of_latency/$sum_of_pck : 0;

        return sprintf("%.1f", $avg);

}