1700 lines
60 KiB
Perl
1700 lines
60 KiB
Perl
#!usr/bin/perl -w
|
|
# use the strict mode
|
|
use strict;
|
|
# Use the Shell enviornment
|
|
#use Shell;
|
|
# Use the time
|
|
use Time::gmtime;
|
|
# Use switch module
|
|
#use Switch;
|
|
use File::Path;
|
|
use Cwd;
|
|
use FileHandle;
|
|
# Multi-thread support
|
|
use threads;
|
|
use threads::shared;
|
|
# use ceil and floor numeric function
|
|
use POSIX;
|
|
|
|
# Date
|
|
my $mydate = gmctime();
|
|
# Current Path
|
|
my $cwd = getcwd();
|
|
|
|
# Global Variants
|
|
# input Option Hash
|
|
my %opt_h;
|
|
my $opt_ptr = \%opt_h;
|
|
# configurate file hash
|
|
my %conf_h;
|
|
my $conf_ptr = \%conf_h;
|
|
# reports hash
|
|
my %rpt_h;
|
|
my $rpt_ptr = \%rpt_h;
|
|
# tb_names hash
|
|
my %tb_names_h;
|
|
my $tb_names_ptr = \%tb_names_h;
|
|
|
|
# Benchmarks
|
|
my @benchmark_names;
|
|
my %benchmarks;
|
|
my $benchmarks_ptr = \%benchmarks;
|
|
my %task_status;
|
|
my $task_status_ptr = \%task_status;
|
|
|
|
# Testbench names
|
|
my @pb_mux_tb_names;
|
|
my @cb_mux_tb_names;
|
|
my @sb_mux_tb_names;
|
|
my @lut_tb_names;
|
|
my @hardlogic_tb_names;
|
|
my @grid_tb_names;
|
|
my @cb_tb_names;
|
|
my @sb_tb_names;
|
|
my @top_tb_name;
|
|
|
|
# Configuration file keywords list
|
|
# Category for conf file.
|
|
# main category : 1st class
|
|
my @mctgy;
|
|
# sub category : 2nd class
|
|
my @sctgy;
|
|
# Initialize these categories
|
|
@mctgy = ("dir_path",
|
|
"task_conf",
|
|
"csv_tags",
|
|
);
|
|
# refer to the keywords of dir_path
|
|
@{$sctgy[0]} = ("result_dir",
|
|
"shell_script_name",
|
|
"top_tb_dir_name",
|
|
"grid_tb_dir_name",
|
|
"lut_tb_dir_name",
|
|
"hardlogic_tb_dir_name",
|
|
"pb_mux_tb_dir_name",
|
|
"cb_mux_tb_dir_name",
|
|
"sb_mux_tb_dir_name",
|
|
"cb_tb_dir_name",
|
|
"sb_tb_dir_name",
|
|
"top_tb_prefix",
|
|
"pb_mux_tb_prefix",
|
|
"cb_mux_tb_prefix",
|
|
"sb_mux_tb_prefix",
|
|
"lut_tb_prefix",
|
|
"hardlogic_tb_prefix",
|
|
"grid_tb_prefix",
|
|
"cb_tb_prefix",
|
|
"sb_tb_prefix",
|
|
"top_tb_postfix",
|
|
"pb_mux_tb_postfix",
|
|
"cb_mux_tb_postfix",
|
|
"sb_mux_tb_postfix",
|
|
"lut_tb_postfix",
|
|
"hardlogic_tb_postfix",
|
|
"grid_tb_postfix",
|
|
"cb_tb_postfix",
|
|
"sb_tb_postfix",
|
|
);
|
|
# refer to the keywords of flow_type
|
|
@{$sctgy[1]} = ("auto_check",
|
|
"num_pb_mux_tb",
|
|
"num_cb_mux_tb",
|
|
"num_sb_mux_tb",
|
|
"num_lut_mux_tb",
|
|
"num_hardlogic_tb",
|
|
"num_grid_mux_tb",
|
|
"num_top_tb",
|
|
"num_cb_tb",
|
|
"num_sb_tb",
|
|
);
|
|
# refer to the keywords of csv_tags
|
|
@{$sctgy[2]} = ("top_tb_leakage_power_tags",
|
|
"top_tb_dynamic_power_tags",
|
|
"pb_mux_tb_leakage_power_tags",
|
|
"pb_mux_tb_dynamic_power_tags",
|
|
"cb_mux_tb_leakage_power_tags",
|
|
"cb_mux_tb_dynamic_power_tags",
|
|
"sb_mux_tb_leakage_power_tags",
|
|
"sb_mux_tb_dynamic_power_tags",
|
|
"lut_tb_leakage_power_tags",
|
|
"lut_tb_dynamic_power_tags",
|
|
"hardlogic_tb_leakage_power_tags",
|
|
"hardlogic_tb_dynamic_power_tags",
|
|
"grid_tb_leakage_power_tags",
|
|
"grid_tb_dynamic_power_tags",
|
|
"cb_tb_leakage_power_tags",
|
|
"cb_tb_dynamic_power_tags",
|
|
"sb_tb_leakage_power_tags",
|
|
"sb_tb_dynamic_power_tags",
|
|
);
|
|
|
|
# ----------Subrountines------------#
|
|
# Print TABs and strings
|
|
sub tab_print($ $ $)
|
|
{
|
|
my ($FILE,$str,$num_tab) = @_;
|
|
my ($my_tab) = (" ");
|
|
|
|
for (my $i = 0; $i < $num_tab; $i++) {
|
|
print $FILE "$my_tab";
|
|
}
|
|
print $FILE "$str";
|
|
}
|
|
|
|
# Create paths if it does not exist.
|
|
sub generate_path($)
|
|
{
|
|
my ($mypath) = @_;
|
|
if (!(-e "$mypath"))
|
|
{
|
|
mkpath "$mypath";
|
|
print "Path($mypath) does not exist...Create it.\n";
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
# Print the usage
|
|
sub print_usage()
|
|
{
|
|
print "Usage:\n";
|
|
print " run_fpga_spice.pl [-options <value>]\n";
|
|
print " Mandatory options: \n";
|
|
print " -conf <file> : specify the basic configuration files for run_fpga_spice\n";
|
|
print " -task <file> : the configuration file contains benchmark file names\n";
|
|
print " -rpt <file> : CSV file consists of data\n";
|
|
print " Other Options:\n";
|
|
print " -monte_carlo <simple_rpt|detail_rpt>: Specify Monte Carlo simulation is enabled in FPGA-SPICE, specify the type of reports. (Simple: only max/min/avg is reported; Detail: every MC case is reported.\n";
|
|
print " -parse_pb_mux_tb: parse the results in pb_mux_testbench\n";
|
|
print " -parse_cb_mux_tb: parse the results in cb_mux_testbench\n";
|
|
print " -parse_sb_mux_tb: parse the results in sb_mux_testbench\n";
|
|
print " -parse_lut_tb: parse the results in lut_testbench\n";
|
|
print " -parse_hardlogic_tb: parse the results in hardlogic_testbench\n";
|
|
print " -parse_grid_tb: parse the results in grid_testbench\n";
|
|
print " -parse_cb_tb: parse the results in cb_testbench\n";
|
|
print " -parse_sb_tb: parse the results in sb_testbench\n";
|
|
print " -parse_top_tb: parse the results in top_testbench\n";
|
|
print " -multi_thread <int>: turn on multi-thread mode, specify the number of processors could be pushed\n";
|
|
print " -sim_leakage_power_only : simulate leakage power only.\n";
|
|
print " -parse_results_only : only parse HSPICE simulation results\n";
|
|
print " -debug : debug mode\n";
|
|
print " -help : print usage\n";
|
|
exit(1);
|
|
return 1;
|
|
}
|
|
|
|
sub spot_option($ $) {
|
|
my ($start,$target) = @_;
|
|
my ($arg_no,$flag) = (-1,"unfound");
|
|
for (my $iarg = $start; $iarg < $#ARGV+1; $iarg++) {
|
|
if ($ARGV[$iarg] eq $target) {
|
|
if ("found" eq $flag) {
|
|
print "Error: Repeated Arguments!(IndexA: $arg_no,IndexB: $iarg)\n";
|
|
&print_usage();
|
|
} else {
|
|
$flag = "found";
|
|
$arg_no = $iarg;
|
|
}
|
|
}
|
|
}
|
|
# return the arg_no if target is found
|
|
# or return -1 when target is missing
|
|
return $arg_no;
|
|
}
|
|
|
|
# Specify in the input list,
|
|
# 1. Option Name
|
|
# 2. Whether Option with value. if yes, choose "on"
|
|
# 3. Whether Option is mandatory. If yes, choose "on"
|
|
sub read_opt_into_hash($ $ $) {
|
|
my ($opt_name,$opt_with_val,$mandatory) = @_;
|
|
# Check the -$opt_name
|
|
my ($opt_fact) = ("-".$opt_name);
|
|
my ($cur_arg) = (0);
|
|
my ($argfd) = (&spot_option($cur_arg,"$opt_fact"));
|
|
if ($opt_with_val eq "on") {
|
|
if (-1 != $argfd) {
|
|
if ($ARGV[$argfd+1] =~ m/^-/) {
|
|
print "The next argument cannot start with '-'!\n";
|
|
print "it implies an option!\n";
|
|
} else {
|
|
$opt_ptr->{"$opt_name\_val"} = $ARGV[$argfd+1];
|
|
$opt_ptr->{"$opt_name"} = "on";
|
|
}
|
|
} else {
|
|
$opt_ptr->{"$opt_name"} = "off";
|
|
if ($mandatory eq "on") {
|
|
print "Mandatory option: $opt_fact is missing!\n";
|
|
&print_usage();
|
|
}
|
|
}
|
|
} else {
|
|
if (-1 != $argfd) {
|
|
$opt_ptr->{"$opt_name"} = "on";
|
|
} else {
|
|
$opt_ptr->{"$opt_name"} = "off";
|
|
if ($mandatory eq "on") {
|
|
print "Mandatory option: $opt_fact is missing!\n";
|
|
&print_usage();
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
# Read options
|
|
sub opts_read() {
|
|
# if no arguments detected, print the usage.
|
|
if (-1 == $#ARGV) {
|
|
print "Error : No input arguments!\n";
|
|
&print_usage();
|
|
exit(1);
|
|
}
|
|
# Read in the options
|
|
my ($cur_arg,$arg_found);
|
|
$cur_arg = 0;
|
|
print "Analyzing your options...\n";
|
|
# Read the options with internal options
|
|
my $argfd;
|
|
# Check help fist
|
|
$argfd = &spot_option($cur_arg,"-help");
|
|
if (-1 != $argfd) {
|
|
print "Help desk:\n";
|
|
&print_usage();
|
|
}
|
|
# Then Check the debug with highest priority
|
|
$argfd = &spot_option($cur_arg,"-debug");
|
|
if (-1 != $argfd) {
|
|
$opt_ptr->{"debug"} = "on";
|
|
} else {
|
|
$opt_ptr->{"debug"} = "off";
|
|
}
|
|
# Check mandatory options
|
|
# Check the -conf
|
|
# Read Opt into Hash(opt_ptr) : "opt_name","with_val","mandatory"
|
|
&read_opt_into_hash("conf","on","on");
|
|
&read_opt_into_hash("task","on","on");
|
|
&read_opt_into_hash("rpt","on","on");
|
|
|
|
# Optional options
|
|
&read_opt_into_hash("monte_carlo","on","off");
|
|
&read_opt_into_hash("sim_leakage_power_only","off","off");
|
|
&read_opt_into_hash("parse_results_only","off","off");
|
|
&read_opt_into_hash("multi_thread","on","off");
|
|
&read_opt_into_hash("parse_pb_mux_tb","off","off");
|
|
&read_opt_into_hash("parse_cb_mux_tb","off","off");
|
|
&read_opt_into_hash("parse_sb_mux_tb","off","off");
|
|
&read_opt_into_hash("parse_lut_tb","off","off");
|
|
&read_opt_into_hash("parse_hardlogic_tb","off","off");
|
|
&read_opt_into_hash("parse_grid_tb","off","off");
|
|
&read_opt_into_hash("parse_cb_tb","off","off");
|
|
&read_opt_into_hash("parse_sb_tb","off","off");
|
|
&read_opt_into_hash("parse_top_tb","off","off");
|
|
|
|
&print_opts();
|
|
|
|
return 1;
|
|
}
|
|
|
|
# List the options
|
|
sub print_opts() {
|
|
print "List your options\n";
|
|
|
|
while(my ($key,$value) = each(%opt_h)) {
|
|
print "$key : $value\n";
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
# Read each line and ignore the comments which starts with given arg
|
|
# return the valid information of line
|
|
sub read_line($ $) {
|
|
my ($line,$com) = @_;
|
|
my @chars;
|
|
if (defined($line)) {
|
|
@chars = split/$com/,$line;
|
|
if (!($line =~ m/[\w\d]/)) {
|
|
$chars[0] = undef;
|
|
}
|
|
if ($line =~ m/^\s*$com/) {
|
|
$chars[0] = undef;
|
|
}
|
|
} else {
|
|
$chars[0] = undef;
|
|
}
|
|
if (defined($chars[0])) {
|
|
$chars[0] =~ s/^(\s+)//g;
|
|
$chars[0] =~ s/(\s+)$//g;
|
|
}
|
|
return $chars[0];
|
|
}
|
|
|
|
# Check each keywords has been defined in configuration file
|
|
sub check_keywords_conf() {
|
|
for (my $imcg = 0; $imcg<$#mctgy+1; $imcg++) {
|
|
for (my $iscg = 0; $iscg<$#{$sctgy[$imcg]}+1; $iscg++) {
|
|
if (defined($conf_ptr->{$mctgy[$imcg]}->{$sctgy[$imcg]->[$iscg]}->{val})) {
|
|
if ("on" eq $opt_ptr->{debug}) {
|
|
print "Keyword($mctgy[$imcg],$sctgy[$imcg]->[$iscg]) = ";
|
|
print "$conf_ptr->{$mctgy[$imcg]}->{$sctgy[$imcg]->[$iscg]}->{val}";
|
|
print "\n";
|
|
}
|
|
} else {
|
|
die "Error: Keyword($mctgy[$imcg],$sctgy[$imcg]->[$iscg]) is missing!\n";
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
# Read the configuration file
|
|
sub read_conf() {
|
|
# Read in these key words
|
|
my ($line,$post_line);
|
|
my @equation;
|
|
my $cur = "unknown";
|
|
open (CONF, "< $opt_ptr->{conf_val}") or die "Fail to open $opt_ptr->{conf_val}!\n";
|
|
print "Reading $opt_ptr->{conf_val}...\n";
|
|
while(defined($line = <CONF>)) {
|
|
chomp $line;
|
|
$post_line = &read_line($line,"#");
|
|
if (defined($post_line)) {
|
|
if ($post_line =~ m/\[(\w+)\]/) {
|
|
$cur = $1;
|
|
} elsif ("unknown" eq $cur) {
|
|
die "Error: Unknown tags for this line!\n$post_line\n";
|
|
} else {
|
|
$post_line =~ s/\s//g;
|
|
@equation = split /=/,$post_line;
|
|
if (!(defined($equation[1]))) {
|
|
$equation[1] = "";
|
|
}
|
|
$conf_ptr->{$cur}->{$equation[0]}->{val} = $equation[1];
|
|
}
|
|
}
|
|
}
|
|
# Check these key words
|
|
print "Read complete!\n";
|
|
&check_keywords_conf();
|
|
print "Checking these keywords...";
|
|
print "Successfully\n";
|
|
close(CONF);
|
|
return 1;
|
|
}
|
|
|
|
sub read_benchmarks() {
|
|
# Read in file names
|
|
my ($line,$post_line,$cur);
|
|
$cur = 0;
|
|
open (FCONF,"< $opt_ptr->{task_val}") or die "Fail to open $opt_ptr->{task}!\n";
|
|
print "Reading $opt_ptr->{task_val}...\n";
|
|
while(defined($line = <FCONF>)) {
|
|
chomp $line;
|
|
$post_line = &read_line($line,"#");
|
|
if (defined($post_line)) {
|
|
$post_line =~ s/\s+//g;
|
|
my @tokens = split(",",$post_line);
|
|
# first is the benchmark name,
|
|
#the second is the channel width, if applicable
|
|
if ($#tokens < 2) {
|
|
die "ERROR: invalid definition for a benchmark! At least include 3 tokens!\n";
|
|
}
|
|
if ($tokens[0]) {
|
|
$benchmark_names[$cur] = $tokens[0];
|
|
} else {
|
|
die "ERROR: invalid definition for benchmarks!\n";
|
|
}
|
|
$benchmarks_ptr->{"$benchmark_names[$cur]"}->{spice_netlist_prefix} = $tokens[1];
|
|
$benchmarks_ptr->{"$benchmark_names[$cur]"}->{spice_dir} = $tokens[2];
|
|
$cur++;
|
|
}
|
|
}
|
|
print "Benchmarks(total $cur):\n";
|
|
foreach my $temp(@benchmark_names) {
|
|
print "$temp\n";
|
|
}
|
|
close(FCONF);
|
|
return 1;
|
|
}
|
|
|
|
# Input program path is like "~/program_dir/program_name"
|
|
# We split it from the scalar
|
|
sub split_prog_path($) {
|
|
my ($prog_path) = @_;
|
|
my @path_elements = split /\//,$prog_path;
|
|
my ($prog_dir,$prog_name);
|
|
|
|
$prog_name = $path_elements[$#path_elements];
|
|
$prog_dir = $prog_path;
|
|
$prog_dir =~ s/$prog_name$//g;
|
|
|
|
return ($prog_dir,$prog_name);
|
|
}
|
|
|
|
# Detect and convert unit, NO Case Insentive.
|
|
sub process_unit($ $)
|
|
{
|
|
my ($unit,$type) = @_;
|
|
my ($ret,$coeff) = (0,0);
|
|
|
|
# Check type, can be <time|power|voltage|capacitance>
|
|
if ("time" eq $type) {
|
|
$unit =~ s/s$//i;
|
|
} elsif ("current" eq $type) {
|
|
$unit =~ s/A$//; # Special should not mix with "a" = 1e-18
|
|
} elsif ("power" eq $type) {
|
|
$unit =~ s/W$//;
|
|
} elsif ("voltage" eq $type) {
|
|
$unit =~ s/V$//;
|
|
} elsif ("capacitance" eq $type) {
|
|
$unit =~ s/F$//; # Special should not mix with "f" = 1e-15
|
|
} elsif ("empty" ne $type) {
|
|
die "Error: (process_unit)Unknown type!Should be <time|power|voltage|capacitance|empty>\n";
|
|
}
|
|
|
|
# Accepte unit: m = 1e-3, u = 1e-6, n = 1e-9, p = 1e-12, f = 1e-15, a = 1e-18
|
|
if ($unit =~ m/a$/) {
|
|
$unit =~ s/a$//;
|
|
$coeff = 1e-18;
|
|
} elsif ($unit =~ m/f$/) {
|
|
$unit =~ s/f$//;
|
|
$coeff = 1e-15;
|
|
} elsif ($unit =~ m/p$/) {
|
|
$unit =~ s/p$//;
|
|
$coeff = 1e-12;
|
|
} elsif ($unit =~ m/n$/) {
|
|
$unit =~ s/n$//;
|
|
$coeff = 1e-9;
|
|
} elsif ($unit =~ m/u$/) {
|
|
$unit =~ s/u$//;
|
|
$coeff = 1e-6;
|
|
} elsif ($unit =~ m/m$/) {
|
|
$unit =~ s/m$//;
|
|
$coeff = 1e-3;
|
|
} elsif ($unit =~ m/k$/) {
|
|
$unit =~ s/k$//;
|
|
$coeff = 1e3;
|
|
} elsif ($unit =~ m/Meg$/) {
|
|
$unit =~ s/Meg$//;
|
|
$coeff = 1e6;
|
|
} elsif ($unit =~ m/\d$/i) {
|
|
$coeff = 1;
|
|
}
|
|
# Chomp the possible point at the end
|
|
$unit =~ s/\.$//;
|
|
|
|
# Quick check, there should be only numbers in remaining
|
|
if (!($unit =~ m/\d$/)) {
|
|
die "Error: (process_unit) Invalid number($unit)!\n";
|
|
}
|
|
|
|
return $ret = $unit*$coeff;
|
|
}
|
|
|
|
# TODO: Check settings
|
|
sub check_fpga_spice() {
|
|
# Format the dir_path
|
|
# Format SPICE prefix
|
|
}
|
|
|
|
# Initialize the status of all tasks
|
|
sub init_tasks_status() {
|
|
foreach my $bm(@benchmark_names) {
|
|
$task_status_ptr->{$bm}->{status} = "wait";
|
|
$task_status_ptr->{$bm}->{thread_id} = undef;
|
|
}
|
|
}
|
|
|
|
sub check_all_fpga_spice_tasks_done() {
|
|
foreach my $bm(@benchmark_names) {
|
|
if ("done" ne $task_status_ptr->{$bm}->{status}) {
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
sub mark_all_fpga_spice_tasks_done() {
|
|
foreach my $bm(@benchmark_names) {
|
|
$task_status_ptr->{$bm}->{status} = "done";
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
sub print_tasks_status() {
|
|
my ($num_jobs_running, $num_jobs_to_run, $num_jobs_finish, $num_jobs) = (0, 0, 0, 0);
|
|
|
|
foreach my $benchmark(@benchmark_names) {
|
|
# Count the number of jobs
|
|
$num_jobs++;
|
|
# Count to do jobs
|
|
if ("wait" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
$num_jobs_to_run++;
|
|
next;
|
|
}
|
|
if ("running" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
# Count running jobs
|
|
$num_jobs_running++;
|
|
next;
|
|
}
|
|
# Count finished jobs
|
|
if ("done" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
$num_jobs_finish++;
|
|
next;
|
|
}
|
|
}
|
|
if ($num_jobs == ($num_jobs_running + $num_jobs_finish + $num_jobs_to_run)) {
|
|
print "Jobs Progress: (Finish rate = ".sprintf("%.2f",100*$num_jobs_finish/$num_jobs) ."%)\n";
|
|
print "Thead utilization rate = ".sprintf("%.2f",100*$num_jobs_running/$opt_ptr->{multi_thread_val})."%\n";
|
|
print "Total No. of Jobs: $num_jobs.\n";
|
|
print "No. of Running Jobs: $num_jobs_running.\n";
|
|
print "No. of Finished Jobs: $num_jobs_finish.\n";
|
|
print "No. of To Run Jobs: $num_jobs_to_run.\n";
|
|
} else {
|
|
print "Internal problem: num_jobs($num_jobs) != num_jobs_running($num_jobs_running)\n";
|
|
print " +num_jobs_finish($num_jobs_finish)\n";
|
|
die " +num_jobs_to_run($num_jobs_to_run)\n";
|
|
}
|
|
return;
|
|
}
|
|
|
|
sub format_dir_path($) {
|
|
my ($dir_path) = @_;
|
|
my ($formatted_dir_path) = ($dir_path);
|
|
|
|
if (!($formatted_dir_path =~ m/\/$/)) {
|
|
$formatted_dir_path = $formatted_dir_path."/";
|
|
}
|
|
|
|
return $formatted_dir_path;
|
|
}
|
|
|
|
sub gen_fpga_spice_netlists_path($ $ $) {
|
|
my ($spice_dir, $sp_prefix, $sp_postfix) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
|
|
my ($sp_path) = ($formatted_spice_dir.$sp_prefix.$sp_postfix);
|
|
|
|
return ($sp_path);
|
|
}
|
|
|
|
sub determine_fpga_grid_nx_ny($) {
|
|
my ($grid_no) = @_;
|
|
|
|
my ($nx, $ny) = (ceil(sqrt($grid_no)), ceil(sqrt($grid_no)));
|
|
|
|
return ($nx, $ny);
|
|
}
|
|
|
|
sub gen_fpga_tb_spice_netlist_path($ $ $ $ $ $) {
|
|
my ($spice_dir, $sp_prefix, $tb_prefix, $ix, $iy, $sp_postfix) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
|
|
my ($sp_path) = ($formatted_spice_dir.$sp_prefix.$tb_prefix.$ix."_".$iy.$sp_postfix);
|
|
|
|
return ($sp_path);
|
|
}
|
|
|
|
sub gen_fpga_spice_measure_results_path($ $ $) {
|
|
my ($spice_dir, $sp_prefix, $sp_postfix) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($formatted_result_dir) = &format_dir_path($conf_ptr->{dir_path}->{result_dir}->{val});
|
|
|
|
my ($mt_path) = ($formatted_spice_dir.$formatted_result_dir.$sp_prefix.$sp_postfix);
|
|
|
|
$mt_path =~ s/\.sp/.mt0/;
|
|
|
|
return ($mt_path);
|
|
}
|
|
|
|
sub gen_fpga_tb_spice_measure_results_path($ $ $ $ $) {
|
|
my ($spice_dir, $sp_prefix, $tb_prefix, $no, $sp_postfix) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($formatted_result_dir) = &format_dir_path($conf_ptr->{dir_path}->{result_dir}->{val});
|
|
|
|
my ($mt_path) = ($formatted_spice_dir.$formatted_result_dir.$sp_prefix.$tb_prefix.$no.$sp_postfix);
|
|
|
|
$mt_path =~ s/\.sp/.mt0/;
|
|
|
|
return ($mt_path);
|
|
}
|
|
|
|
sub convert_fpga_tb_names_to_measure_names($) {
|
|
my ($tb_sp_path, $spice_dir) = @_;
|
|
my ($mt_path);
|
|
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($formatted_result_dir) = &format_dir_path($conf_ptr->{dir_path}->{result_dir}->{val});
|
|
|
|
# Split tb_sp_path
|
|
my @sp_parts = split('/', $tb_sp_path);
|
|
my ($mt_name) = ($sp_parts[$#sp_parts]);
|
|
$mt_name =~ s/\.sp$/\.mt0/g;
|
|
|
|
($mt_path) = ($formatted_spice_dir.$formatted_result_dir.$mt_name);
|
|
|
|
return $mt_path;
|
|
}
|
|
|
|
sub remove_fpga_spice_results($) {
|
|
my ($spice_dir) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($formatted_result_dir) = &format_dir_path($conf_ptr->{dir_path}->{result_dir}->{val});
|
|
|
|
my ($result_dir_path) = ($formatted_spice_dir.$formatted_result_dir);
|
|
|
|
#rmtree($result_dir_path,1,1);
|
|
`rm -rf $result_dir_path/`;
|
|
print "INFO: Simulation Results($result_dir_path) are removed...\n";
|
|
|
|
#`rm -rf $spice_dir/`;
|
|
#print "INFO: Spice Directory($spice_dir) is removed...\n";
|
|
|
|
return;
|
|
}
|
|
|
|
sub check_one_spice_lis_error($) {
|
|
my ($lis_path) = @_;
|
|
my ($line, $line_no, $warn_no, $err_no) = (undef,0,0,0);
|
|
my ($LISFH) = FileHandle->new;
|
|
|
|
print "INFO: Checking LIS file($lis_path)...\n";
|
|
|
|
if (!(-e $lis_path)) {
|
|
die "ERROR: Fail to find SPICE lis file($lis_path)!\n";
|
|
}
|
|
if ($LISFH->open("< $lis_path")) {
|
|
while(defined($line = <$LISFH>)) {
|
|
chomp $line;
|
|
$line_no++;
|
|
if ($line =~ m/error/i) {
|
|
$err_no++;
|
|
print "ERROR($err_no),LIS FILE[LINE$line_no]: ".$line."\n";
|
|
}
|
|
if ($line =~ m/warning/i) {
|
|
$warn_no++;
|
|
print "WARNING($warn_no),LIS FILE[LINE$line_no]: ".$line."\n";
|
|
}
|
|
}
|
|
} else {
|
|
die "ERROR: fail to open $lis_path!\n";
|
|
}
|
|
# Close the lis file
|
|
close($LISFH);
|
|
# Print HSPICE ERROR and Warning Stats
|
|
print "HSPICE Sim. reports $err_no errors and $warn_no warnings.\n";
|
|
if ($err_no > 0) {
|
|
die "ERROR: Terminate due to errors in HSPICE Sim. reports.\n";
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
sub check_one_fpga_spice_task_lis($ $ $) {
|
|
my ($benchmark, $spice_netlist_prefix, $spice_dir) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($shell_script_path) = $formatted_spice_dir.$conf_ptr->{dir_path}->{shell_script_name}->{val};
|
|
my ($itb, $lis_file_path);
|
|
|
|
if ("on" eq $opt_ptr->{parse_top_tb}) {
|
|
my ($top_lis_path) = &gen_fpga_spice_measure_results_path($formatted_spice_dir, $spice_netlist_prefix,$conf_ptr->{dir_path}->{top_tb_postfix}->{val});
|
|
$top_lis_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($top_lis_path);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_pb_mux_tb}) {
|
|
# generate measure results paths
|
|
@pb_mux_tb_names = split (',', $tb_names_ptr->{$benchmark}->{pb_mux_tb_names});
|
|
foreach my $tb_sp_filename (@pb_mux_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_mux_tb}) {
|
|
# generate measure results paths
|
|
@cb_mux_tb_names = split (',', $tb_names_ptr->{$benchmark}->{cb_mux_tb_names});
|
|
foreach my $tb_sp_filename (@cb_mux_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_mux_tb}) {
|
|
# generate measure results paths
|
|
@sb_mux_tb_names = split (',', $tb_names_ptr->{$benchmark}->{sb_mux_tb_names});
|
|
foreach my $tb_sp_filename (@sb_mux_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_lut_tb}) {
|
|
# generate measure results paths
|
|
@lut_tb_names = split (',', $tb_names_ptr->{$benchmark}->{lut_tb_names});
|
|
foreach my $tb_sp_filename (@lut_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if (0 == $conf_ptr->{task_conf}->{num_hardlogic_tb}->{val}) {
|
|
} elsif ("on" eq $opt_ptr->{parse_hardlogic_tb}) {
|
|
# generate measure results paths
|
|
@hardlogic_tb_names = split (',', $tb_names_ptr->{$benchmark}->{hardlogic_tb_names});
|
|
foreach my $tb_sp_filename (@hardlogic_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_grid_tb}) {
|
|
# generate measure results paths
|
|
@grid_tb_names = split (',', $tb_names_ptr->{$benchmark}->{grid_tb_names});
|
|
foreach my $tb_sp_filename (@grid_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_tb}) {
|
|
# generate measure results paths
|
|
@cb_tb_names = split (',', $tb_names_ptr->{$benchmark}->{cb_tb_names});
|
|
foreach my $tb_sp_filename (@cb_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_tb}) {
|
|
# generate measure results paths
|
|
@sb_tb_names = split (',', $tb_names_ptr->{$benchmark}->{sb_tb_names});
|
|
foreach my $tb_sp_filename (@sb_tb_names) {
|
|
$lis_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path =~ s/\.mt0/.lis/;
|
|
&check_one_spice_lis_error($lis_file_path);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
sub init_one_fpga_spice_task_one_tb_results($ $ $ $) {
|
|
my ($benchmark, $tbname_tag, $tb_leakage_tags, $tb_dynamic_tags) = @_;
|
|
my (@leakage_tags) = split('\|', $tb_leakage_tags);
|
|
my (@dynamic_tags) = split('\|', $tb_dynamic_tags);
|
|
my ($temp);
|
|
|
|
# Check if there is any conflict to reserved words
|
|
foreach my $tag(@leakage_tags) {
|
|
if (("peak_mem_used" eq $tag)||("total_elapsed_time" eq $tag)) {
|
|
die "ERROR: $tbname_tag leakage_power_tags has a conflict word($tag)!\n";
|
|
}
|
|
}
|
|
if ("off" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
foreach my $tag(@dynamic_tags) {
|
|
if (("peak_mem_used" eq $tag)||("total_elapsed_time" eq $tag)) {
|
|
die "ERROR: $tbname_tag dynamic_power_tags has a conflict word($tag)!\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used} = 0;
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{total_elapsed_time} = 0;
|
|
foreach my $tag(@leakage_tags) {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag} = 0;
|
|
}
|
|
if ("off" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
foreach my $tag(@dynamic_tags) {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag} = 0;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
sub parse_one_fpga_spice_task_one_regular_tb_results($ $ $ $ $ $) {
|
|
my ($benchmark, $tbname_tag, $tb_lispath, $tb_mtpath, $tb_leakage_tags, $tb_dynamic_tags) = @_;
|
|
my (@leakage_tags) = split('\|', $tb_leakage_tags);
|
|
my (@dynamic_tags) = split('\|', $tb_dynamic_tags);
|
|
my ($line, $found_tran_analysis);
|
|
my ($LISFH) = FileHandle->new;
|
|
my ($temp);
|
|
|
|
# Check if there is any conflict to reserved words
|
|
foreach my $tag(@leakage_tags) {
|
|
if (("peak_mem_used" eq $tag)||("total_elapsed_time" eq $tag)) {
|
|
die "ERROR: $tbname_tag leakage_power_tags has a conflict word($tag)!\n";
|
|
}
|
|
}
|
|
if ("off" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
foreach my $tag(@dynamic_tags) {
|
|
if (("peak_mem_used" eq $tag)||("total_elapsed_time" eq $tag)) {
|
|
die "ERROR: $tbname_tag dynamic_power_tags has a conflict word($tag)!\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!(-e $tb_lispath)) {
|
|
die "ERROR: Fail to find SPICE lis file($tb_lispath)!\n";
|
|
}
|
|
if ($LISFH->open("< $tb_lispath")) {
|
|
$found_tran_analysis = 0;
|
|
while(defined($line = <$LISFH>)) {
|
|
chomp $line;
|
|
if ((0 == $found_tran_analysis)&&($line =~ m/transient\s+analysis/)) {
|
|
$found_tran_analysis = 1;
|
|
}
|
|
if (0 == $found_tran_analysis) {
|
|
next;
|
|
}
|
|
# Special: get peak memory used and total elapsed time
|
|
if ($line =~ m/peak\s+memory\s+used\s+([\d.]+)\s+megabytes/i) {
|
|
$temp = $1;
|
|
if ((!defined($rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used}))
|
|
||($rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used} < $temp)) {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used} = $temp;
|
|
}
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
# Special: get peak memory used and total elapsed time
|
|
if ($line =~ m/total\s+elapsed\s+time\s+([\d.]+)\s+seconds/i) {
|
|
$temp = $1;
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{total_elapsed_time} += $temp;
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
# For leakage power
|
|
foreach my $tag(@leakage_tags) {
|
|
if ($line =~ m/$tag\s*=\s*([\d.\w\-\+]+)/i) {
|
|
$temp = $1;
|
|
$temp = &process_unit($temp, "empty");
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{avg} += $temp;
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
}
|
|
# Bypass dynamic tags if leakage_only is enabled
|
|
if ("on" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
next;
|
|
}
|
|
# For dynamic power
|
|
foreach my $tag(@dynamic_tags) {
|
|
if ($line =~ m/$tag\s*=\s*([\d.\w\-\+]+)/i) {
|
|
$temp = $1;
|
|
$temp = &process_unit($temp, "empty");
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{avg} += $temp;
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
die "ERROR: fail to open $tb_lispath!\n";
|
|
}
|
|
# Close file
|
|
close($LISFH);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
sub parse_one_fpga_spice_task_one_mc_tb_results($ $ $ $ $ $ $) {
|
|
my ($benchmark, $tbname_tag, $tb_lispath, $tb_mtpath, $tb_leakage_tags, $tb_dynamic_tags) = @_;
|
|
my (@leakage_tags) = split('\|', $tb_leakage_tags);
|
|
my (@dynamic_tags) = split('\|', $tb_dynamic_tags);
|
|
my ($line, $found_tran_analysis);
|
|
my ($LISFH) = FileHandle->new;
|
|
my ($temp, $mc_cnt) = ("", 0);
|
|
|
|
# Check if there is any conflict to reserved words
|
|
foreach my $tag(@leakage_tags) {
|
|
if (("peak_mem_used" eq $tag)||("total_elapsed_time" eq $tag)) {
|
|
die "ERROR: $tbname_tag leakage_power_tags has a conflict word($tag)!\n";
|
|
}
|
|
# for a clear start
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{mc_cnt} = 0;
|
|
}
|
|
if ("off" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
foreach my $tag(@dynamic_tags) {
|
|
if (("peak_mem_used" eq $tag)||("total_elapsed_time" eq $tag)
|
|
||("mc_min" eq $tag)||("mc_max" eq $tag)||("mc_avg" eq $tag)
|
|
||("mc_total" eq $tag)||("mc_cnt" eq $tag)) {
|
|
die "ERROR: $tbname_tag dynamic_power_tags has a conflict word($tag)!\n";
|
|
}
|
|
# for a clear start
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{mc_cnt} = 0;
|
|
}
|
|
}
|
|
|
|
if (!(-e $tb_lispath)) {
|
|
die "ERROR: Fail to find SPICE lis file($tb_lispath)!\n";
|
|
}
|
|
if ($LISFH->open("< $tb_lispath")) {
|
|
$found_tran_analysis = 0;
|
|
while(defined($line = <$LISFH>)) {
|
|
chomp $line;
|
|
if ((0 == $found_tran_analysis)&&($line =~ m/transient\s+analysis/)) {
|
|
$found_tran_analysis = 1;
|
|
}
|
|
if (0 == $found_tran_analysis) {
|
|
next;
|
|
}
|
|
# Special: get peak memory used and total elapsed time
|
|
if ($line =~ m/peak\s+memory\s+used\s+([\d.]+)\s+megabytes/i) {
|
|
$temp = $1;
|
|
if ((!defined($rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used}))
|
|
||($rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used} < $temp)) {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used} = $temp;
|
|
}
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
# Special: get peak memory used and total elapsed time
|
|
if ($line =~ m/total\s+elapsed\s+time\s+([\d.]+)\s+seconds/i) {
|
|
$temp = $1;
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{total_elapsed_time} += $temp;
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
# For leakage power
|
|
foreach my $tag(@leakage_tags) {
|
|
if ($line =~ m/$tag\s*=\s*([\d.\w\-\+]+)/i) {
|
|
$temp = $1;
|
|
$temp = &process_unit($temp, "empty");
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{mc_cnt} += 1;
|
|
$mc_cnt = $rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{mc_cnt};
|
|
if (defined($rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{"mc".$mc_cnt})) {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{"mc".$mc_cnt} += $temp;
|
|
} else {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{"mc".$mc_cnt} = $temp;
|
|
}
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
}
|
|
# Bypass dynamic tags if leakage_only is enabled
|
|
if ("on" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
next;
|
|
}
|
|
# For dynamic power
|
|
foreach my $tag(@dynamic_tags) {
|
|
if ($line =~ m/$tag\s*=\s*([\d.\w\-\+]+)/i) {
|
|
$temp = $1;
|
|
$temp = &process_unit($temp, "empty");
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{mc_cnt} += 1;
|
|
$mc_cnt = $rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{mc_cnt};
|
|
if (defined($rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{"mc".$mc_cnt})) {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{"mc".$mc_cnt} += $temp;
|
|
} else {
|
|
$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{"mc".$mc_cnt} = $temp;
|
|
}
|
|
next; # We find a match, ignore the rest
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
die "ERROR: fail to open $tb_lispath!\n";
|
|
}
|
|
# Close file
|
|
close($LISFH);
|
|
|
|
return;
|
|
}
|
|
|
|
sub parse_one_fpga_spice_task_one_tb_results($ $ $ $ $ $) {
|
|
my ($benchmark, $tbname_tag, $tb_lispath, $tb_mtpath, $tb_leakage_tags, $tb_dynamic_tags) = @_;
|
|
|
|
if ("on" eq $opt_ptr->{monte_carlo}) {
|
|
&parse_one_fpga_spice_task_one_mc_tb_results($benchmark, $tbname_tag, $tb_lispath, $tb_mtpath,
|
|
$tb_leakage_tags, $tb_dynamic_tags);
|
|
} else {
|
|
&parse_one_fpga_spice_task_one_regular_tb_results($benchmark, $tbname_tag, $tb_lispath, $tb_mtpath,
|
|
$tb_leakage_tags, $tb_dynamic_tags);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
sub count_num_tb_one_folder($) {
|
|
my ($dir) = @_;
|
|
my (@files) = <$dir/*.sp>;
|
|
my ($count) = $#files + 1;
|
|
return $count;
|
|
}
|
|
|
|
sub get_tb_file_names($) {
|
|
my ($tb_dir) = @_;
|
|
my @ret_file_names;
|
|
my ($dh);
|
|
|
|
# Search all the sp files matching the name
|
|
opendir($dh, $tb_dir) || die "Fail to open directory of $tb_dir\n";
|
|
@ret_file_names = grep(/\.sp$/, readdir($dh));
|
|
print "Getting testbench file names for $tb_dir ...\n";
|
|
closedir($dh);
|
|
|
|
# join the names together
|
|
my ($ret) = join(",", @ret_file_names);
|
|
|
|
return $ret;
|
|
}
|
|
|
|
sub auto_check_tb_num($ $ $) {
|
|
my ($benchmark, $spice_netlist_prefix, $spice_dir) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($tb_dir);
|
|
|
|
print "Autocheck Results:\n";
|
|
|
|
# count pb_mux_tb
|
|
$conf_ptr->{task_conf}->{num_pb_mux_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{pb_mux_tb_dir_name}->{val});
|
|
print "INFO: No. of CLB MUXes testbenches = $conf_ptr->{task_conf}->{num_pb_mux_tb}->{val}\n";
|
|
|
|
# count sb_mux_tb
|
|
$conf_ptr->{task_conf}->{num_sb_mux_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{sb_mux_tb_dir_name}->{val});
|
|
print "INFO: No. of Switch Box MUXes testbenches = $conf_ptr->{task_conf}->{num_sb_mux_tb}->{val}\n";
|
|
|
|
# count cb_mux_tb
|
|
$conf_ptr->{task_conf}->{num_cb_mux_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{cb_mux_tb_dir_name}->{val});
|
|
print "INFO: No. of Connection Box MUXes testbenches = $conf_ptr->{task_conf}->{num_cb_mux_tb}->{val}\n";
|
|
|
|
# count lut_tb
|
|
$conf_ptr->{task_conf}->{num_lut_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{lut_tb_dir_name}->{val});
|
|
print "INFO: No. of LUT testbenches = $conf_ptr->{task_conf}->{num_lut_tb}->{val}\n";
|
|
|
|
# count hardlogic_tb
|
|
$conf_ptr->{task_conf}->{num_hardlogic_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{hardlogic_tb_dir_name}->{val});
|
|
print "INFO: No. of FF testbenches = $conf_ptr->{task_conf}->{num_hardlogic_tb}->{val}\n";
|
|
|
|
# count grid_tb
|
|
$conf_ptr->{task_conf}->{num_grid_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{grid_tb_dir_name}->{val});
|
|
print "INFO: No. of Grid testbenches = $conf_ptr->{task_conf}->{num_grid_tb}->{val}\n";
|
|
|
|
# count cb_tb
|
|
$conf_ptr->{task_conf}->{num_cb_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{cb_tb_dir_name}->{val});
|
|
print "INFO: No. of CB testbenches = $conf_ptr->{task_conf}->{num_cb_tb}->{val}\n";
|
|
|
|
# count sb_tb
|
|
$conf_ptr->{task_conf}->{num_sb_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{sb_tb_dir_name}->{val});
|
|
print "INFO: No. of SB testbenches = $conf_ptr->{task_conf}->{num_sb_tb}->{val}\n";
|
|
|
|
# count top_tb
|
|
$conf_ptr->{task_conf}->{num_top_tb}->{val} = &count_num_tb_one_folder($formatted_spice_dir.$conf_ptr->{dir_path}->{top_tb_dir_name}->{val});
|
|
print "INFO: No. of Top-level testbench = $conf_ptr->{task_conf}->{num_top_tb}->{val}\n";
|
|
|
|
my ($toptb_sp_path) = &gen_fpga_spice_netlists_path($formatted_spice_dir.$conf_ptr->{dir_path}->{top_tb_dir_name}->{val}, $spice_netlist_prefix, $conf_ptr->{dir_path}->{top_tb_postfix}->{val});
|
|
|
|
if (("on" eq $opt_ptr->{parse_top_tb})&&(!(-e $toptb_sp_path))) {
|
|
die "ERROR: File($toptb_sp_path) does not exist!";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_pb_mux_tb}) {
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{pb_mux_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{pb_mux_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_mux_tb}) {
|
|
# Search all the sp files matching the name
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{cb_mux_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{cb_mux_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_mux_tb}) {
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{sb_mux_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{sb_mux_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_lut_tb}) {
|
|
# Search all the sp files matching the name
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{lut_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{lut_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
# Special, if there is no hardlogic, this is comb circuit, we don't collect the information
|
|
if (0 == $conf_ptr->{task_conf}->{num_hardlogic_tb}->{val}) {
|
|
print "INFO: None DFF testbenches detected... This may caused by a combinational circuit!\n";
|
|
} elsif ("on" eq $opt_ptr->{parse_hardlogic_tb}) {
|
|
# Search all the sp files matching the name
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{hardlogic_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{hardlogic_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_grid_tb}) {
|
|
# Search all the sp files matching the name
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{grid_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{grid_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_tb}) {
|
|
# Search all the sp files matching the name
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{cb_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{cb_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_tb}) {
|
|
# Search all the sp files matching the name
|
|
$tb_dir = $formatted_spice_dir.$conf_ptr->{dir_path}->{sb_tb_dir_name}->{val};
|
|
$tb_names_ptr->{$benchmark}->{sb_tb_names} = &get_tb_file_names($tb_dir);
|
|
}
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
sub parse_one_fpga_spice_task_results($ $ $) {
|
|
my ($benchmark, $spice_netlist_prefix, $spice_dir) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($shell_script_path) = $formatted_spice_dir.$conf_ptr->{dir_path}->{shell_script_name}->{val};
|
|
my ($itb, $mt_file_path, $lis_file_path);
|
|
|
|
&auto_check_tb_num($benchmark, $spice_netlist_prefix, $spice_dir);
|
|
|
|
if ("on" eq $opt_ptr->{parse_top_tb}) {
|
|
my ($top_mt_path) = &gen_fpga_spice_measure_results_path($spice_dir, $spice_netlist_prefix,$conf_ptr->{dir_path}->{top_tb_postfix}->{val});
|
|
my ($top_lis_path) = ($top_mt_path);
|
|
$top_lis_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"top_tb", $top_lis_path, $top_mt_path, $conf_ptr->{csv_tags}->{top_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{top_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_pb_mux_tb}) {
|
|
# generate measure results paths
|
|
@pb_mux_tb_names = split (',', $tb_names_ptr->{$benchmark}->{pb_mux_tb_names});
|
|
foreach my $tb_sp_filename (@pb_mux_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"pb_mux_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{pb_mux_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{pb_mux_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_mux_tb}) {
|
|
# generate measure results paths
|
|
@cb_mux_tb_names = split (',', $tb_names_ptr->{$benchmark}->{cb_mux_tb_names});
|
|
foreach my $tb_sp_filename (@cb_mux_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"cb_mux_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{cb_mux_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{cb_mux_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_mux_tb}) {
|
|
# generate measure results paths
|
|
@sb_mux_tb_names = split (',', $tb_names_ptr->{$benchmark}->{sb_mux_tb_names});
|
|
foreach my $tb_sp_filename (@sb_mux_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"sb_mux_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{sb_mux_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{sb_mux_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_lut_tb}) {
|
|
# generate measure results paths
|
|
@lut_tb_names = split (',', $tb_names_ptr->{$benchmark}->{lut_tb_names});
|
|
foreach my $tb_sp_filename (@lut_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"lut_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{lut_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{lut_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if (0 == $conf_ptr->{task_conf}->{num_hardlogic_tb}->{val}) {
|
|
&init_one_fpga_spice_task_one_tb_results($benchmark,"hardlogic_tb",$conf_ptr->{csv_tags}->{hardlogic_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{hardlogic_tb_dynamic_power_tags}->{val});
|
|
} elsif ("on" eq $opt_ptr->{parse_hardlogic_tb}) {
|
|
# generate measure results paths
|
|
@hardlogic_tb_names = split (',', $tb_names_ptr->{$benchmark}->{hardlogic_tb_names});
|
|
foreach my $tb_sp_filename (@hardlogic_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"hardlogic_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{hardlogic_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{hardlogic_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_grid_tb}) {
|
|
# generate measure results paths
|
|
@grid_tb_names = split (',', $tb_names_ptr->{$benchmark}->{grid_tb_names});
|
|
foreach my $tb_sp_filename (@grid_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"grid_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{grid_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{grid_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_tb}) {
|
|
# generate measure results paths
|
|
@cb_tb_names = split (',', $tb_names_ptr->{$benchmark}->{cb_tb_names});
|
|
foreach my $tb_sp_filename (@cb_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"cb_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{cb_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{cb_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_tb}) {
|
|
# generate measure results paths
|
|
@sb_tb_names = split (',', $tb_names_ptr->{$benchmark}->{sb_tb_names});
|
|
foreach my $tb_sp_filename (@sb_tb_names) {
|
|
$mt_file_path = &convert_fpga_tb_names_to_measure_names($tb_sp_filename, $spice_dir);
|
|
$lis_file_path = $mt_file_path;
|
|
$lis_file_path =~ s/\.mt0$/.lis/;
|
|
&parse_one_fpga_spice_task_one_tb_results($benchmark,"sb_tb", $lis_file_path, $mt_file_path, $conf_ptr->{csv_tags}->{sb_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{sb_tb_dynamic_power_tags}->{val});
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
# Run a fpga_spice_task
|
|
sub run_one_fpga_spice_task($ $ $) {
|
|
my ($benchmark, $spice_netlist_prefix, $spice_dir) = @_;
|
|
my ($formatted_spice_dir) = &format_dir_path($spice_dir);
|
|
my ($shell_script_path) = $formatted_spice_dir.$conf_ptr->{dir_path}->{shell_script_name}->{val};
|
|
my ($itb, $ix, $iy, $dh, $tb_dir);
|
|
|
|
# change to the spice_dir
|
|
chdir $spice_dir;
|
|
# Check all the SPICE netlists and shell scripts exist
|
|
|
|
&auto_check_tb_num($benchmark, $spice_netlist_prefix, $spice_dir);
|
|
|
|
if (!(-e $shell_script_path)) {
|
|
die "ERROR: File($shell_script_path) does not exist!";
|
|
}
|
|
|
|
# Call the shell script
|
|
print "INFO: Running shell script ($shell_script_path)...\n";
|
|
`csh -cx 'source $shell_script_path'`
|
|
or die "ERROR: fail in executing $shell_script_path!\n";
|
|
|
|
# return to current dir
|
|
chdir $cwd;
|
|
|
|
&check_one_fpga_spice_task_lis($benchmark, $spice_netlist_prefix, $spice_dir);
|
|
print "INFO: Check LIS file finished.\n";
|
|
|
|
return;
|
|
}
|
|
|
|
sub parse_all_tasks_results() {
|
|
print "Parsing all the results...\n";
|
|
foreach my $benchmark(@benchmark_names) {
|
|
if ("done" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
print "Parsing simulation results for benchmark($benchmark)...\n";
|
|
&parse_one_fpga_spice_task_results($benchmark,$benchmarks_ptr->{$benchmark}->{spice_netlist_prefix},$benchmarks_ptr->{$benchmark}->{spice_dir});
|
|
} else {
|
|
die "ERROR: found unfinished tasks when try to parse results!\n";
|
|
}
|
|
# Remove results to avoid storage overflow
|
|
#&remove_fpga_spice_results($benchmarks_ptr->{$benchmark}->{spice_dir});
|
|
}
|
|
}
|
|
|
|
# Multi-thread Running FPGA SPICE tasks
|
|
sub multi_thread_run_fpga_spice_tasks($) {
|
|
my ($num_threads) = @_;
|
|
|
|
# Evaluate include threads ok
|
|
if (!(eval 'use threads; 1')) {
|
|
die "ERROR: cannot use threads package in Perl! Please check the installation of package...\n";
|
|
}
|
|
# Lauch threads up to the limited number of threads number
|
|
if ($num_threads < 2) {
|
|
$num_threads = 2;
|
|
}
|
|
my ($num_thread_running) = (0);
|
|
|
|
# Iterate until all the tasks has been assigned, finished
|
|
while (1 != &check_all_fpga_spice_tasks_done()) {
|
|
foreach my $benchmark(@benchmark_names) {
|
|
# Bypass finished job
|
|
if ("done" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
next;
|
|
}
|
|
# Check running job
|
|
if ("running" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
my ($thr_id) = ($task_status_ptr->{$benchmark}->{thread_id});
|
|
if (!($thr_id)) {
|
|
die "INTERNAL ERROR: invalid thread_id for task: $benchmark!\n";
|
|
}
|
|
# Check if there is any error
|
|
if ($thr_id->error()) {
|
|
die "ERROR: Task: $benchmark, Thread(ID:$thr_id) exit abnormally!\n";
|
|
}
|
|
if ($thr_id->is_running()) {
|
|
$task_status_ptr->{$benchmark}->{status} = "running";
|
|
}
|
|
if ($thr_id->is_joinable()) {
|
|
$num_thread_running--;
|
|
$thr_id->join(); # Join the thread results
|
|
# Update task status
|
|
$task_status_ptr->{$benchmark}->{status} = "done";
|
|
print "INFO: task: $benchmark finished!\n";
|
|
&print_tasks_status();
|
|
}
|
|
next;
|
|
}
|
|
# If we reach the thread number limit, we have to wait...
|
|
if (($num_thread_running == $num_threads)
|
|
||($num_thread_running > $num_threads)) {
|
|
next;
|
|
}
|
|
# Start a new thread for a waiting task
|
|
if ("wait" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
# We try to start a new thread since there are still threads available
|
|
my ($thr_new) = (threads->create(\&run_one_fpga_spice_task, $benchmark,$benchmarks_ptr->{$benchmark}->{spice_netlist_prefix},$benchmarks_ptr->{$benchmark}->{spice_dir}));
|
|
if ($thr_new) {
|
|
print "INFO: a new thread for task (benchmark: $benchmark) is lauched!\n";
|
|
# Update status
|
|
$task_status_ptr->{$benchmark}->{status} = "running";
|
|
$task_status_ptr->{$benchmark}->{thread_id} = $thr_new;
|
|
$num_thread_running++;
|
|
&print_tasks_status();
|
|
} else {
|
|
# Fail to create a new thread, wait...
|
|
print "INFO: fail to lauch a new thread for task (benchmark: $benchmark)!\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
&print_tasks_status();
|
|
|
|
# Parse_results
|
|
&parse_all_tasks_results();
|
|
}
|
|
|
|
# Single-thread mode Running FPGA SPICE tasks
|
|
sub single_thread_run_fpga_spice_tasks() {
|
|
# Iterate until all the tasks has been assigned, finished
|
|
while (1 != &check_all_fpga_spice_tasks_done()) {
|
|
foreach my $benchmark(@benchmark_names) {
|
|
# Bypass finished job
|
|
if ("done" eq $task_status_ptr->{$benchmark}->{status}) {
|
|
next;
|
|
}
|
|
&run_one_fpga_spice_task($benchmark,$benchmarks_ptr->{$benchmark}->{spice_netlist_prefix},$benchmarks_ptr->{$benchmark}->{spice_dir});
|
|
&parse_one_fpga_spice_task_results($benchmark,$benchmarks_ptr->{$benchmark}->{spice_netlist_prefix},$benchmarks_ptr->{$benchmark}->{spice_dir});
|
|
$task_status_ptr->{$benchmark}->{status} = "done";
|
|
# Remove results to avoid storage overflow
|
|
&remove_fpga_spice_results($benchmarks_ptr->{$benchmark}->{spice_dir});
|
|
}
|
|
}
|
|
# Parse_results
|
|
#&parse_all_tasks_results();
|
|
return;
|
|
}
|
|
|
|
# Plan to run tasks
|
|
sub plan_run_tasks() {
|
|
&init_tasks_status();
|
|
|
|
if (("on" eq $opt_ptr->{multi_thread})
|
|
&&(1 < $opt_ptr->{multi_thread_val})
|
|
&&(1 < ($#benchmark_names + 1))) {
|
|
&multi_thread_run_fpga_spice_tasks($opt_ptr->{multi_thread_val});
|
|
} else {
|
|
if ("on" eq $opt_ptr->{multi_thread}) {
|
|
print "INFO: multi_thread is selected but only 1 processor can be used or 1 benchmark to run...\n";
|
|
print "INFO: switch to single thread mode.\n";
|
|
}
|
|
&single_thread_run_fpga_spice_tasks();
|
|
}
|
|
}
|
|
|
|
sub gen_csv_rpt_one_tb_one_case($ $ $ $ $) {
|
|
my ($RPTFH, $tbname_tag, $tb_leakage_tags, $tb_dynamic_tags, $case_tag) = @_;
|
|
my (@leakage_tags) = split('\|', $tb_leakage_tags);
|
|
my (@dynamic_tags) = split('\|', $tb_dynamic_tags);
|
|
|
|
# Print Title line
|
|
print $RPTFH "Benchmark,SimElapseTime,SimPeakMemUsed,";
|
|
foreach my $tag(@leakage_tags) {
|
|
print $RPTFH "$tag,";
|
|
}
|
|
if ("off" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
foreach my $tag(@dynamic_tags) {
|
|
print $RPTFH "$tag,";
|
|
}
|
|
}
|
|
print $RPTFH "\n";
|
|
foreach my $benchmark(@benchmark_names) {
|
|
print $RPTFH "$benchmark,";
|
|
print $RPTFH "$rpt_ptr->{$benchmark}->{$tbname_tag}->{total_elapsed_time},";
|
|
print $RPTFH "$rpt_ptr->{$benchmark}->{$tbname_tag}->{peak_mem_used},";
|
|
foreach my $tag(@leakage_tags) {
|
|
print $RPTFH "$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{$case_tag},";
|
|
}
|
|
if ("off" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
foreach my $tag(@dynamic_tags) {
|
|
print $RPTFH "$rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag}->{$case_tag},";
|
|
}
|
|
}
|
|
print $RPTFH "\n";
|
|
}
|
|
return;
|
|
}
|
|
|
|
sub gen_csv_rpt_one_case($ $) {
|
|
my ($RPTFH, $case_tag) = @_;
|
|
|
|
print $RPTFH "Monte Carlo case tag of the results: $case_tag\n";
|
|
|
|
if ("on" eq $opt_ptr->{parse_pb_mux_tb}) {
|
|
print $RPTFH "***** pb_mux_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "pb_mux_tb", $conf_ptr->{csv_tags}->{pb_mux_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{pb_mux_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_mux_tb}) {
|
|
print $RPTFH "***** cb_mux_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "cb_mux_tb", $conf_ptr->{csv_tags}->{cb_mux_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{cb_mux_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_mux_tb}) {
|
|
print $RPTFH "***** sb_mux_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "sb_mux_tb", $conf_ptr->{csv_tags}->{sb_mux_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{sb_mux_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_lut_tb}) {
|
|
print $RPTFH "***** lut_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "lut_tb", $conf_ptr->{csv_tags}->{lut_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{lut_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_hardlogic_tb}) {
|
|
print $RPTFH "***** hardlogic_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "hardlogic_tb", $conf_ptr->{csv_tags}->{hardlogic_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{hardlogic_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_grid_tb}) {
|
|
print $RPTFH "***** grid_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "grid_tb", $conf_ptr->{csv_tags}->{grid_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{grid_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_tb}) {
|
|
print $RPTFH "***** cb_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "cb_tb", $conf_ptr->{csv_tags}->{cb_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{cb_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_tb}) {
|
|
print $RPTFH "***** sb_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "sb_tb", $conf_ptr->{csv_tags}->{sb_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{sb_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_top_tb}) {
|
|
print $RPTFH "***** top_tb Results Table *****\n";
|
|
&gen_csv_rpt_one_tb_one_case($RPTFH, "top_tb", $conf_ptr->{csv_tags}->{top_tb_leakage_power_tags}->{val}, $conf_ptr->{csv_tags}->{top_tb_dynamic_power_tags}->{val}, $case_tag);
|
|
print $RPTFH "\n";
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
sub process_mc_data_one_tag($) {
|
|
my ($cur_mc_hash_ref) = @_;
|
|
|
|
$cur_mc_hash_ref->{mc_total} = 0;
|
|
$cur_mc_hash_ref->{mc_avg} = "na";
|
|
$cur_mc_hash_ref->{mc_max} = "na";
|
|
$cur_mc_hash_ref->{mc_min} = "na";
|
|
for (my $i = 1;
|
|
$i < $cur_mc_hash_ref->{mc_cnt} + 1;
|
|
$i++) {
|
|
$cur_mc_hash_ref->{mc_total} += $cur_mc_hash_ref->{"mc".$i};
|
|
# Update max
|
|
if (("na" eq $cur_mc_hash_ref->{mc_max})
|
|
||($cur_mc_hash_ref->{mc_max} < $cur_mc_hash_ref->{"mc".$i})) {
|
|
$cur_mc_hash_ref->{mc_max} = $cur_mc_hash_ref->{"mc".$i};
|
|
}
|
|
# Update min
|
|
if (("na" eq $cur_mc_hash_ref->{mc_min})
|
|
||($cur_mc_hash_ref->{mc_min} > $cur_mc_hash_ref->{"mc".$i})) {
|
|
$cur_mc_hash_ref->{mc_min} = $cur_mc_hash_ref->{"mc".$i};
|
|
}
|
|
}
|
|
# Get average
|
|
if ( 0 < $cur_mc_hash_ref->{mc_cnt}) {
|
|
$cur_mc_hash_ref->{mc_avg} = $cur_mc_hash_ref->{mc_total} / $cur_mc_hash_ref->{mc_cnt};
|
|
}
|
|
|
|
return $cur_mc_hash_ref->{mc_cnt};
|
|
}
|
|
|
|
# Count the number of Monte Carlo simulations,
|
|
# and calculate the average, max and min
|
|
sub process_mc_data_one_tb($ $ $) {
|
|
my ($tbname_tag, $tb_leakage_tags, $tb_dynamic_tags) = @_;
|
|
my (@leakage_tags) = split('\|', $tb_leakage_tags);
|
|
my (@dynamic_tags) = split('\|', $tb_dynamic_tags);
|
|
my ($mc_cnt, $mc_cnt_temp) = (0, 0);
|
|
|
|
# Check each benchmark
|
|
foreach my $benchmark(@benchmark_names) {
|
|
foreach my $tag(@leakage_tags) {
|
|
$mc_cnt_temp = &process_mc_data_one_tag($rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag});
|
|
if (0 == $mc_cnt_temp) {
|
|
print "Warning: zero results found in Monte Carlo simulations for $tag!\n";
|
|
}
|
|
if (0 == $mc_cnt) {
|
|
$mc_cnt = $mc_cnt_temp;
|
|
} elsif ($mc_cnt != $mc_cnt_temp) {
|
|
print "Warning: Inconsistent Monte Carlo Counter for (Benchmark:$benchmark; Testbench: $tbname_tag, Tag:$tag)\n";
|
|
}
|
|
}
|
|
|
|
# Only do the next part when sim_leakage is disabled
|
|
if ("on" eq $opt_ptr->{sim_leakage_power_only}) {
|
|
next;
|
|
}
|
|
foreach my $tag(@dynamic_tags) {
|
|
$mc_cnt_temp = &process_mc_data_one_tag($rpt_ptr->{$benchmark}->{$tbname_tag}->{$tag});
|
|
if (0 == $mc_cnt) {
|
|
$mc_cnt = $mc_cnt_temp;
|
|
} elsif ($mc_cnt != $mc_cnt_temp) {
|
|
print "Warning: Inconsistent Monte Carlo Counter for (Benchmark:$benchmark; Testbench: $tbname_tag, Tag:$tag)\n";
|
|
}
|
|
}
|
|
}
|
|
return $mc_cnt;
|
|
}
|
|
|
|
|
|
sub process_mc_results() {
|
|
my ($mc_cnt) = (0);
|
|
|
|
if ("on" eq $opt_ptr->{parse_pb_mux_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("pb_mux_tb",
|
|
$conf_ptr->{csv_tags}->{pb_mux_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{pb_mux_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_mux_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("cb_mux_tb",
|
|
$conf_ptr->{csv_tags}->{cb_mux_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{cb_mux_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_mux_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("sb_mux_tb",
|
|
$conf_ptr->{csv_tags}->{sb_mux_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{sb_mux_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_lut_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("lut_tb",
|
|
$conf_ptr->{csv_tags}->{lut_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{lut_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_hardlogic_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("hardlogic_tb",
|
|
$conf_ptr->{csv_tags}->{hardlogic_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{hardlogic_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_grid_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("grid_tb",
|
|
$conf_ptr->{csv_tags}->{grid_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{grid_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_cb_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("cb_tb",
|
|
$conf_ptr->{csv_tags}->{cb_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{cb_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_sb_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("sb_tb",
|
|
$conf_ptr->{csv_tags}->{sb_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{sb_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{parse_top_tb}) {
|
|
$mc_cnt =
|
|
&process_mc_data_one_tb("top_tb",
|
|
$conf_ptr->{csv_tags}->{top_tb_leakage_power_tags}->{val},
|
|
$conf_ptr->{csv_tags}->{top_tb_dynamic_power_tags}->{val});
|
|
}
|
|
|
|
return $mc_cnt;
|
|
}
|
|
|
|
sub gen_csv_rpt($) {
|
|
my ($rpt_file) = @_;
|
|
my ($RPTFH) = FileHandle->new;
|
|
my ($mc_num) = (0);
|
|
|
|
my ($rpt_dir_path, $rpt_filename) = &split_prog_path($rpt_file);
|
|
&generate_path($rpt_dir_path);
|
|
|
|
if ($RPTFH->open("> $rpt_file")) {
|
|
print "INFO: print CVS report($rpt_file)...\n";
|
|
} else {
|
|
die "ERROR: fail to create $rpt_file!\n";
|
|
}
|
|
|
|
if ("on" eq $opt_ptr->{monte_carlo}) {
|
|
# Preprocess the data
|
|
$mc_num = &process_mc_results();
|
|
# Output starts
|
|
if ("simple_rpt" eq $opt_ptr->{monte_carlo_val}) {
|
|
&gen_csv_rpt_one_case($RPTFH, "mc_avg");
|
|
&gen_csv_rpt_one_case($RPTFH, "mc_max");
|
|
&gen_csv_rpt_one_case($RPTFH, "mc_min");
|
|
} else { # Output full report
|
|
print $RPTFH "Number of Monte Carlo simulations: $mc_num\n\n";
|
|
&gen_csv_rpt_one_case($RPTFH, "mc_avg");
|
|
&gen_csv_rpt_one_case($RPTFH, "mc_max");
|
|
&gen_csv_rpt_one_case($RPTFH, "mc_min");
|
|
for (my $i = 1; $i < $mc_num + 1; $i++) {
|
|
&gen_csv_rpt_one_case($RPTFH, "mc".$i);
|
|
}
|
|
}
|
|
} else {
|
|
&gen_csv_rpt_one_case($RPTFH, "avg");
|
|
}
|
|
|
|
close($RPTFH);
|
|
return;
|
|
}
|
|
|
|
# Main Program
|
|
sub main() {
|
|
&opts_read();
|
|
&read_conf();
|
|
&read_benchmarks();
|
|
&check_fpga_spice();
|
|
# Auto check the number tbs
|
|
if ("on" eq $opt_ptr->{parse_results_only}) {
|
|
&mark_all_fpga_spice_tasks_done();
|
|
&parse_all_tasks_results();
|
|
} else {
|
|
&plan_run_tasks();
|
|
}
|
|
&gen_csv_rpt($opt_ptr->{rpt_val});
|
|
}
|
|
&main();
|
|
exit(0);
|