Subversion Repositories theia_gpu

#!/usr/bin/perl
 
# This is the main simulation environment laucnher script.
# It will create a regression area under a folder with a
# unique name.
#
#
#
#
 
use strict;
use Cwd;
use File::Copy;
use File::Find;
use HTTP::Date;
use Time::HiRes;
use Data::Dumper;
#use File::Copy::Recursive;
 
#Globals
my $SimulationCommand          = undef;
my @SimulationFiles            = undef;
my $SimulationBinary           = undef;
my $RegressionTargetDirectory  = undef;
my %TestList                   = undef;
 
 
my 
$ScriptPath = getcwd();
print "Running from $ScriptPath\n";
#Read the configuration from this file
eval Slurp( "testlist.pl" );
die "-E- Errors in configuration file!\n".$@."\n" if($@);
 
my $Scale = 131072; # 2^17
CreateTargetTree( $RegressionTargetDirectory );
#----------------------------------------------------------------
sub hashValueAscendingNum {
   $TestList{$a}->{'run_index'} <=> $TestList{$b}->{'run_index'};
}
 
#----------------------------------------------------------------
sub CreateTargetTree
{
  my $DestinationPath = shift;
  my ($date, $time) = split(" ", HTTP::Date::time2iso());
  $time =~ s/:/_/g;
  my $RegDir = "$RegressionTargetDirectory/regression_${date}_${time}";
  mkdir $RegDir or die "Cannot create regression folder '$RegDir' $!\n";
 
  #Create the regression.log
  open LOG, ">$RegDir/regression.log" or die "Cannot create file regression log file '$RegDir/Regression.log' $!\n";
  print LOG "Regression Test-bench started at $date ,time $time\n";
  #Collect some information about the system
  my $system = `uname -a`;
  my $memory = `cat /proc/meminfo | grep -i memtotal`;
  my $cpu = `cat /proc/cpuinfo | grep -i model | grep name`;
  print LOG "System: $system\n";
  print LOG "RAM: $memory\n";
  print LOG "CPU:\n$cpu\n";
 
  #for my $i (0 .. $#TestList)
  #print Dumper(%TestList);
  for my $TestName (sort hashValueAscendingNum (keys %TestList))
  {
	chdir $ScriptPath;
	my $TestPath = $TestList{$TestName}->{'path'};
 
 
 
		print LOG "-----------------------------------------------------------------------------------\n";
		print LOG "Scene: '$TestName'\n";
        my $TestDir = "$RegDir/$TestName";
 
        mkdir $TestDir;
        #Copy compulsory files
        copy("$TestPath/Vertex.mem","$TestDir/") or die "-E- $TestPath/Vertex.mem $!\n";
        copy("$TestPath/Params.mem","$TestDir/") or die "-E- $TestPath/Params.mem $!\n";
        copy("$TestPath/Creg.mem","$TestDir/") or die "-E- $TestPath/Config.mem $!\n";
        copy("$TestPath/Reference.ppm","$TestDir/") or die "-E- $TestPath/Reference.ppm $!\n";
		copy("$TestPath/Textures.mem","$TestDir/") or die "-E- $TestPath/Textures.ppm $!\n";
		copy("$TestPath/Instructions.mem","$TestDir/") or die "-E- $TestPath/Instructions.ppm $!\n";
		copy("$TestPath/Instructions.mem","$TestDir/") or die "-E- $TestPath/Instructions.ppm $!\n";
		#Print some information about the scene
 
 
		my $Width = $TestList{$TestName}->{'width'};
		my $Height = $TestList{$TestName}->{'height'};
 
		print  LOG "Scene Resolution: $Width x $Height\n";
		my $Line = `grep -i  texture $TestDir/Params.mem`;
		my ($tWidth,$tHeight) = split(" ", $Line); 
		$tWidth = (hex $tWidth)/$Scale;
		$tHeight = (hex $tHeight)/$Scale;
		print  LOG "Texture: $tWidth x $tHeight\n";
		my $TringleCount = `grep -A 1 -i child $TestDir/Vertex.mem | grep -v -i child`;
		print LOG "Triangle count: $TringleCount\n";
 
        #Copy the Source files just in case..
        mkdir "$RegDir/rtl";
		system("cp -vr ../rtl/*.v $RegDir/rtl");
        #copy("../rtl","$RegDir")  or die ("Cannot Copy '" . $_ . "' : $!\n");
 
 
#Compile the test code 
#print Dumper($TestList{$TestName});
my $CoreCount = $TestList{$TestName}->{core_count};
my $MemBankCount = $TestList{$TestName}->{mem_bank_count}; 
printf 
  "
    Compiling Code
	Number of execution cores: $CoreCount
	Number of texture memory banks: $MemBankCount
  ";
 
  chdir "../simulation";
  if ( system("make compile GPUCORES=$CoreCount GPUMEMBANKS=$MemBankCount") != 0)
  {
	die "-E- Error compiling test code! ($!)\n";
  }
 #Now copy the binary over to our simulation directory
 
 
 copy("$SimulationBinary","$TestDir/") or die "-E- $SimulationBinary $!\n";
 
        printf
 "
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 ** Theia Regression Started **
 
 
 Regression Target Directory:
 '$TestDir'
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 ";
 
 
        #Execute the Simulation
        chdir $TestDir;
        my ($StartDate,$StartTime) =   split(" ", HTTP::Date::time2iso());
 
		print LOG "Number of execution cores:         $CoreCount\n";
		print LOG "Number of memory banks:            $MemBankCount\n";
		print LOG "Simulation started at:             $StartDate $StartTime\n";
 
        #system "$SimulationCommand -tclbatch isim.tcl";
		if (system ("perl $ScriptPath/configure_params.pl $CoreCount $Width $Height") != 0)
		{
			die "-E- Error configuing scene parameters! ($!)\n";
		}
		my $StartTime = [Time::HiRes::gettimeofday()];
		if (system("vvp -n $SimulationBinary -none") != 0)
		{
		  print LOG "-E- Error running simulation! ($!)\n";
		}
 
		my $diff = Time::HiRes::tv_interval($StartTime);
		my ($EndDate,$EndTime) =   split(" ", HTTP::Date::time2iso());
        print LOG "Simulation Completed at $EndDate $EndTime\n";
		print LOG "Simulation ran for " . $diff/3600 . " hours\n";
 
 
    ParseOutputPPM( $TestDir );
 
   # system("perl D:/\Proyecto/\RTL/\Scripts/calculate_stats.pl $TestDir/\CU.log $RegDir/\Regression.log $TestDir/\Simulation.log");
 
  }
close LOG;
 
 
 
}
 
#---------------------------------------------------------------- \
sub Slurp
{
    my $file = shift;
    open F, "< $file" or die "Error opening '$file' for read: $!";
    local $/ = undef;
    my $string = <F>;
    close F;
    return $string;
}
#-------------------------------------------------------------------------------
sub Round
{
  my $number = shift;
  my $rounded = sprintf("%.3f", $number);
  return $rounded;
}
#----------------------------------------------------------------
sub ParseOutputPPM()
{
  my $TestDir = shift;
  open FILE, "$TestDir/Output.ppm" or die "Can't open  $TestDir/Output.ppm !$\n";
  my $i = 1;
  my $CurrentRow;
 my $CurrentCol;
  while (<FILE>)
  {
 
   if (m/^#\s*(\d+)\,\s+(\d+)/)
   {
 $CurrentRow = $1;
 $CurrentCol = $2;
   } 
 
   # m/\s*(\d)\s+(\d)\s+(\d).*/;
    if (m/x+/g)
    {
      print LOG "FATAL ERROR: 'Output.ppm' Found 'x' at row = $CurrentRow , col = $CurrentCol = $2, line $i\n" ;
      last;
      return;
    }
     $i++;
  }
  close FILE;
 
 my $TotalTime = 0;
open F, "$TestDir/Simulation.log" or die "$TestDir/Simulation.log' : $!\n";
 
 
local $/=undef;
my $Temp = <F>;
close F;
my($junk,$StartSimTime) = split /Simulation start time \:\s+/,$Temp;
my($junk,$EndSimTime) = split /Simulation end time \:\s+/,$Temp;
$StartSimTime =~ s/ns//;
$EndSimTime =~ s/ns//;
$TotalTime = ($EndSimTime-$StartSimTime)/1000000000;
print LOG "Simulated start time: $StartSimTime\n";
print LOG "Simulated end time: $EndSimTime\n";
print LOG "Total Time: $TotalTime seconds\n";
print LOG "Theorical FPS: ". Round( (1 /$TotalTime) )."\n";
}