#!/usr/bin/perl

###################################################################################
# This script is used to extract and verify statistics of one or more VTR tasks.
#
# Usage:
#	parse_vtr_task.pl <task_name1> <task_name2> ... [OPTIONS]
#
# Options:
# 	-l <task_list_file>: Used to provide a test file containing a list of tasks
#   -create_golden:  Will create/overwrite the golden results with those of the
#						most recent execution
#   -check_golden:  Will verify the results of the most recent execution against
#						the golden results for each task and report either a
#						[Pass] or [Fail]
#   -parse_qor:  	Used for the purposes of parsing quality of results of the
#					most recent execution.
#   -calc_geomean:  Used for the purposes of computing quality of results geomeans 
# 					of the most recent execution.
#
# Authors: Jason Luu and Jeff Goeders
###################################################################################

use strict;
use Cwd;
use File::Spec;
use File::Copy;
use List::Util;
use Math::BigInt;
use POSIX qw/strftime/;

# Function Prototypes
sub trim;
sub parse_single_task;
sub pretty_print_table;
sub summarize_qor;
sub calc_geomean;
sub check_golden;
sub expand_user_path;
sub get_important_file;

# Get Absolute Path of 'vtr_flow
Cwd::abs_path($0) =~ m/(.*vtr_flow)/;
my $vtr_flow_path = $1;

my $run_prefix = "run";

my $FAILED_PARSE_EXIT_CODE = -1;

# Parse Input Arguments
my @tasks;
my @task_files;
my $token;
my $create_golden = 0;
my $check_golden  = 0;
my $parse_qor 	  = 1;  # QoR file is parsed by default; turned off if 
						# user does not specify QoR parse file in config.txt
my $calc_geomean  = 0;  # QoR geomeans are not computed by default;
my $override_exp_id       = 0;
my $revision;
my $verbose       = 0;
my $pretty_print_results = 1;

while ( $token = shift(@ARGV) ) {

	# Check for a task list file
	if ( $token =~ /^-l(.+)$/ ) {
		push( @task_files, expand_user_path($1) );
	}
	elsif ( $token eq "-l" ) {
		push( @task_files, expand_user_path( shift(@ARGV) ) );
	}
	elsif ( $token eq "-create_golden" ) {
		$create_golden = 1;
	}
	elsif ( $token eq "-check_golden" ) {
		$check_golden = 1;
	}
	elsif ( $token eq "-parse_qor" ) {
		$parse_qor = 1;
	}
	elsif ( $token eq "-calc_geomean" ) {
		$calc_geomean = 1;
	}
	elsif ( $token eq "-run") {
	    $override_exp_id = shift(@ARGV);
    }
	elsif ( $token eq "-revision" ) {
		$revision = shift(@ARGV);
	}
	elsif ( $token eq "-v" ) {
		$verbose = 1;
	}
	elsif ( $token =~ /^-/ ) {
		die "Invalid option: $token\n";
	}
	# must be a task name
	else {
		if ( $token =~ /(.*)\/$/ ) {
			$token = $1;
		}
		push( @tasks, $token );
	}
}

# Read Task Files
foreach (@task_files) {
	open( FH, $_ ) or die "$! ($_)\n";
	while (<FH>) {
		push( @tasks, $_ );
	}
	close(FH);
}

my $num_golden_failures = 0;
foreach my $task (@tasks) {
	chomp($task);
	my $failures = parse_single_task($task);
    $num_golden_failures += $failures; 
}

if ($calc_geomean) {
	summarize_qor;
	calc_geomean;
}

exit $num_golden_failures;

sub parse_single_task {
	my $task_name = shift;
	(my $task_path = $task_name) =~ s/\s+$//;

    # first see if task_name is the task path
	if (! -e "$task_path/config/config.txt") {
	    ($task_path = "$vtr_flow_path/tasks/$task_name") =~ s/\s+$//;
    }

	open( CONFIG, "<$task_path/config/config.txt" )
	  or die "Failed to open $task_path/config/config.txt: $!";
	my @config_data = <CONFIG>;
	close(CONFIG);

	my @circuits;
	my $parse_file;
	my $qor_parse_file;
        my $second_parse_file;
	my @archs;
        my $counter = 0;
	foreach my $line (@config_data) {

		# Ignore comments
		if ( $line =~ /^\s*#.*$/ or $line =~ /^\s*$/ ) { next; }

        #Trim off a line-ending comment
        $line =~ s/#.*$//;

		my @data  = split( /=/, $line );
		my $key   = trim( $data[0] );
		my $value = trim( $data[1] );

		if ( $key eq "circuit_list_add" ) {
			push( @circuits, $value );
		}
		elsif ( $key eq "arch_list_add" ) {
			push( @archs, $value );
		}
		elsif ( $key eq "parse_file" ) {
                        if ($counter eq 1){
                                    #second time parse file
                                    $second_parse_file = expand_user_path($value);
                                    $counter = 0;
                                    #don't need to check golden, only compare between two files
                                    $check_golden = 0;
                        }
                        else{
                            $parse_file = expand_user_path($value);
                            $counter = $counter + 1;
                        }
		}
		elsif ( $key eq "qor_parse_file" ) {
			$qor_parse_file = expand_user_path($value);
		}
	}

	# PARSE CONFIG FILE
	if ( $parse_file eq "" ) {
		die "Task $task_name has no parse file specified.\n";
	}
	$parse_file = get_important_file($task_path, $vtr_flow_path, $parse_file);

        if ($second_parse_file){
            $second_parse_file = get_important_file($task_path, $vtr_flow_path, $second_parse_file);
	}

	# Get Max Run #
	opendir(DIR, $task_path);
	my @folders = readdir(DIR);
	closedir(DIR);
	# QOR PARSE CONFIG FILE
	if ( $qor_parse_file eq "" ) {
		print "Task $task_name has no QoR parse file specified. Skipping QoR.\n";
		$parse_qor = 0;
		$calc_geomean = 0;
	}
	else {
	    $qor_parse_file = get_important_file($task_path, $vtr_flow_path, $qor_parse_file);
    }

    my $exp_id = 0;
    if($override_exp_id != 0) {
        #explicitely specified via -run parameter
        $exp_id = $override_exp_id;
    } else {
        # haven't explicitely specified via -run parameter
        $exp_id = last_exp_id(${task_path});
    }
	
	my $run_path = "$task_path/${run_prefix}${exp_id}";

	my $first = 1;
	open( OUTPUT_FILE, ">$run_path/parse_results.txt" );
	foreach my $arch (@archs) {
		foreach my $circuit (@circuits) {
            my $cmd = "$vtr_flow_path/scripts/parse_vtr_flow.pl $run_path/$arch/$circuit $parse_file > $run_path/$arch/$circuit/parse_results.txt";

            my $ret = system($cmd);
            if ($ret != 0) {
                print "System command '$cmd' failed\n";
                exit $FAILED_PARSE_EXIT_CODE;
            }

			open( RESULTS_FILE, "$run_path/$arch/$circuit/parse_results.txt" );
            # first line is heading
			my $output = <RESULTS_FILE>;
			if ($first) {
				print OUTPUT_FILE "arch\tcircuit\t$output";
				$first = 0;
			}
            # second line is actual value
			my $output = <RESULTS_FILE>;
			close(RESULTS_FILE);
			print OUTPUT_FILE $arch . "\t" . $circuit . "\t" . $output;
		}
	}
	close(OUTPUT_FILE);

    #parse the second file the same way as the first if checking rr graph
    if($second_parse_file){
        my $run_path = "$task_path/${run_prefix}${exp_id}";

	my $first = 1;
	open( OUTPUT_FILE, ">$run_path/parse_results_2.txt" );
	foreach my $arch (@archs) {
		foreach my $circuit (@circuits) {
		    my $cmd = "$vtr_flow_path/scripts/parse_vtr_flow.pl $run_path/$arch/$circuit $second_parse_file > $run_path/$arch/$circuit/parse_results_2.txt";

            my $ret = system($cmd);
            if ($ret != 0) {
                print "System command '$cmd' failed\n";
                exit $FAILED_PARSE_EXIT_CODE;
            }

			open( RESULTS_FILE, "$run_path/$arch/$circuit/parse_results_2.txt" );
            # first line is heading
			my $output = <RESULTS_FILE>;
			if ($first) {
				print OUTPUT_FILE "arch\tcircuit\t$output";
				$first = 0;
			}
            # second line is actual value
			my $output = <RESULTS_FILE>;
			close(RESULTS_FILE);
			print OUTPUT_FILE $arch . "\t" . $circuit . "\t" . $output;
		}
	}
	close(OUTPUT_FILE);
    }

    if ($pretty_print_results) {
        pretty_print_table("$run_path/parse_results.txt");
        if ($second_parse_file) {
            pretty_print_table("$run_path/parse_results_2.txt");
        }
    }

	if ($parse_qor) {
		my $first = 1;
		open( OUTPUT_FILE, ">$run_path/qor_results.txt" );
		foreach my $arch (@archs) {
			foreach my $circuit (@circuits) {
				my $cmd = "$vtr_flow_path/scripts/parse_vtr_flow.pl $run_path/$arch/$circuit $qor_parse_file > $run_path/$arch/$circuit/qor_results.txt";

                my $ret = system($cmd);
                if ($ret != 0) {
                    print "System command '$cmd' failed\n";
                    exit $FAILED_PARSE_EXIT_CODE;
                }

				open( RESULTS_FILE, "$run_path/$arch/$circuit/qor_results.txt" );
				my $output = <RESULTS_FILE>;
				if ($first) {
					print OUTPUT_FILE "arch\tcircuit\t$output";
					$first = 0;
				}
				my $output = <RESULTS_FILE>;
				close(RESULTS_FILE);
				print OUTPUT_FILE $arch . "\t" . $circuit . "\t" . $output;
			}
		}
		close(OUTPUT_FILE);
	}

	if ($create_golden) {
		copy( "$run_path/parse_results.txt",
			"$run_path/../config/golden_results.txt" );
	}

        if ($second_parse_file){
            #don't check with golden results, just check the two files
            return check_two_files ( $task_name, $task_path, $run_path, "$run_path/parse_results.txt", "$run_path/parse_results_2.txt", 0);
            
        }

	if ($check_golden) {
        #Returns 1 if failed
            if ($second_parse_file eq ""){
                return check_two_files( $task_name, $task_path, $run_path, "$run_path/parse_results.txt", "$task_path/config/golden_results.txt", $check_golden);
            }
	}

    return 0; #Pass
}

sub summarize_qor {

	##############################################################
	# Set up output file
	##############################################################

	my $first = 1;
	
	my $task = @tasks[0];
	(my $task_path = "$vtr_flow_path/tasks/$task") =~ s/\s+$//;
	
	my $output_path = $task_path;
	my $exp_id = last_exp_id($task_path);

	if ( ( ( $#tasks + 1 ) > 1 ) | ( -e "$task_path/../task_list.txt" ) ) {
		$output_path = "$task_path/../";
	}
	if ( !-e "$output_path/task_summary" ) {
		mkdir "$output_path/task_summary";
	}
	if ( -e "$output_path/task_summary/${run_prefix}${exp_id}_summary.txt" ) {
	}
	open( OUTPUT_FILE, ">$output_path/task_summary/${run_prefix}${exp_id}_summary.txt" );
	
	##############################################################
	# Append contents of QoR files to output file
	##############################################################

	foreach my $task (@tasks) {
		chomp($task);
		($task_path = "$vtr_flow_path/tasks/$task") =~ s/\s+$//;
		$exp_id = last_exp_id($task_path);
		(my $run_path = "$task_path/${run_prefix}${exp_id}") =~ s/\s+$//;

		open( RESULTS_FILE, "$run_path/qor_results.txt" );
		my $output = <RESULTS_FILE>;

		if ($first) {
			print OUTPUT_FILE "task_name\t$output";
			$first = 0;
		}
		
		while ($output = <RESULTS_FILE>) {
			print OUTPUT_FILE $task . "\t" . $output;
		}
		close(RESULTS_FILE);
	}
	close(OUTPUT_FILE);
}

sub calc_geomean {

	##############################################################
	# Set up output file
	##############################################################

	my $first = 0;

	my $task = @tasks[0];
	(my $task_path = "$vtr_flow_path/tasks/$task") =~ s/\s+$//;
	
	my $output_path = $task_path;
	my $exp_id = last_exp_id($task_path);

	if ( ( ( $#tasks + 1 ) > 1 ) | ( -e "$task_path/../task_list.txt" ) ) {
		($output_path = "$task_path/../") =~ s/\s+$//; 
	}
	if ( !-e "$output_path/qor_geomean.txt" ) {
		open( OUTPUT_FILE, ">$output_path/qor_geomean.txt" );
		$first = 1;
	}
	else {
		open( OUTPUT_FILE, ">>$output_path/qor_geomean.txt" );
	}
	
	##############################################################
	# Read summary file
	##############################################################

	my $summary_file = "$output_path/task_summary/${run_prefix}${exp_id}_summary.txt";

	if ( !-r $summary_file ) {
		print "[ERROR] Failed to open $summary_file: $!";
		return;
	}
	open( SUMMARY_FILE, "<$summary_file" );
	my @summary_data = <SUMMARY_FILE>;
	close(SUMMARY_FILE);

	my $summary_params = shift @summary_data;
	my @summary_params = split( /\t/, trim($summary_params) );
	
	if ($first) {
		# Hack - remove unwanted labels
		my $num = 4;
		while ($num) {
			shift @summary_params;
			--$num;
		}
		print OUTPUT_FILE "run";
		my @temp = @summary_params;
		while ( $#temp >= 0 ) {
			my $label = shift @temp;
			print OUTPUT_FILE "\t" . "$label";
		}
		print OUTPUT_FILE "\t" . "date" . "\t" . "revision";
		$first = 0;
	}
	else {
	}

	print OUTPUT_FILE "\n${exp_id}";

	##############################################################
	# Compute & write geomean to output file
	##############################################################

	my $index = 4;
	my @summary_params = split( /\t/, trim($summary_params) );
	
	while ( $#summary_params  >= $index ) {
		my $geomean = 1; my $num = 0;
		foreach my $line (@summary_data) {
			my @first_file_line = split( /\t/, $line );
			if ( trim( @first_file_line[$index] ) > 0 ) {
				$geomean *= trim( @first_file_line[$index] );
				$num++;
			}
		}
		if ($num) {
			$geomean **= 1/$num;
			print OUTPUT_FILE "\t" . "${geomean}";
		}
		else {
			print OUTPUT_FILE "\t" . "-1";
		}
		$index++;
	}
	my $date = strftime( '%D', localtime );
	print OUTPUT_FILE "\t" . "$date" . "\t" . "$revision";
	close(OUTPUT_FILE);
}

sub max {
    my $x = shift;
    my $y = shift;

    return ($x < $y) ? $y : $x;
}

sub pretty_print_table {
    my $file_path = shift;


    #Read the input file
    my @file_data;
    open(INFILE,"<$file_path");
    while(<INFILE>) {
        chomp;
        push(@file_data, [split /\t/])
    }

    #Determine the maximum column width for pretty formatting
    my %col_widths;
    for my $row (0 .. $#file_data) {
        for my $col (0 .. $#{$file_data[$row]}) {

            my $col_width = length $file_data[$row][$col];

            #Do we have a valid column width?
            if (not exists $col_widths{$col}) {
                #Initial width
                $col_widths{$col} = $col_width;
            } else {
                #Max width
                $col_widths{$col} = max($col_widths{$col}, $col_width);
            }

        }
    }

    #Write out in pretty format
    open(OUTFILE,">$file_path");
    for my $row (0 .. $#file_data) {
        for my $col (0 .. $#{$file_data[$row]}) {
            printf OUTFILE "%-*s", $col_widths{$col}, $file_data[$row][$col];

            if($col != $#{$file_data[$row]}) {
                printf OUTFILE "\t";
            }
        }
        printf OUTFILE "\n";
    }
    close(OUTFILE);

}

sub last_exp_id {
	my $path = shift;
	my $num = 0;
    my $run_id = "";
    my $run_id_no_pad = "";
    do {
		++$num;
        $run_id = sprintf("%03d", $num);
        $run_id_no_pad = sprintf("%d", $num);
    } while ( -e "$path/${run_prefix}${run_id}" or -e "$path/${run_prefix}${run_id_no_pad}");
    --$num;
    $run_id = sprintf("%03d", $num);
    $run_id_no_pad = sprintf("%d", $num);

    if( -e "$path/${run_prefix}${run_id}" ) {
        return $run_id;
    } elsif (-e "$path/${run_prefix}${run_id_no_pad}") {
        return $run_id_no_pad;
    }

    die("Unknown experiment id");
} 

sub check_two_files {
	my $task_name = shift;
	my $task_path = shift;
	my $run_path  = shift;
        my $first_test_file_dir = shift;
        my $second_test_file_dir = shift;
        my $is_golden = shift;

    #Did this check pass?
	my $failed = 0;

    print "$task_name...";
    print "\n" if $verbose;

	# Code to check the results of the two files
	(my $test_file_1 = "$first_test_file_dir") =~ s/\s+$//;
	(my $test_file_2 = "$second_test_file_dir") =~ s/s+$//;

	my $pass_req_file;
	open( CONFIG_FILE, "$task_path/config/config.txt" );
	my $lines = do { local $/; <CONFIG_FILE>; };
	close(CONFIG_FILE);

	# Search config file
	if ( $lines =~ /^\s*pass_requirements_file\s*=\s*(\S+)\s*$/m ) { }
	else {
		print
		  "[ERROR] No 'pass_requirements_file' in task configuration file ($task_path/config/config.txt)\n";
        $failed += 1;
		return $failed;
	}

	my $pass_req_filename = $1;

	# Search for pass requirement file
	$pass_req_filename = expand_user_path($pass_req_filename);
	if ( -e "$task_path/config/$pass_req_filename" ) {
		$pass_req_file = "$task_path/config/$pass_req_filename";
	}
	elsif ( -e "$vtr_flow_path/parse/pass_requirements/$pass_req_filename" ) {
		$pass_req_file =
		  "$vtr_flow_path/parse/pass_requirements/$pass_req_filename";
	}
	elsif ( -e $pass_req_filename ) {
		$pass_req_file = $pass_req_filename;
	}
	else {
		print
		  "[ERROR] Cannot find pass_requirements_file.  Checked for $task_path/config/$pass_req_filename or $vtr_flow_path/parse/$pass_req_filename or $pass_req_filename\n";
        $failed = 0;
		return $failed;
	}

	my $line;

	my @first_test_data;
        my @second_test_data;
	my @pass_req_data;

	my @params;
	my %type;
	my %min_threshold;
	my %max_threshold;
	my %abs_diff_threshold;

	##############################################################
	# Read files
	##############################################################
	if ( !-r $test_file_2 ) {
		print "[ERROR] Failed to open $test_file_2: $!";
        $failed += 1;
		return $failed;
	}
	open( GOLDEN_DATA, "<$test_file_2" );
	@second_test_data = <GOLDEN_DATA>;
	close(GOLDEN_DATA);

	if ( !-r $pass_req_file ) {
		print "[ERROR] Failed to open $pass_req_file: $!";
        $failed += 1;
		return $failed;
	}
	open( PASS_DATA, "<$pass_req_file" );
	@pass_req_data = <PASS_DATA>;
	close(PASS_DATA);

	if ( !-r $test_file_1 ) {
		print "[ERROR] Failed to open $test_file_1: $!";
        $failed += 1;
		return $failed;
	}
	open( TEST_DATA, "<$test_file_1" );
	@first_test_data = <TEST_DATA>;
	close(TEST_DATA);

	##############################################################
	# Process and check all parameters for consistency
	##############################################################
	my $second_test_params = shift @second_test_data;
	my $first_test_params   = shift @first_test_data;

	my @second_test_params = split( /\t/, $second_test_params );    # get parameters of the second file results
	my @first_test_params = split( /\t/, $first_test_params );      # get parameters of the first file results

    my @second_test_params = map(trim($_), @second_test_params);
    my @first_test_params = map(trim($_), @first_test_params);

	# Check to ensure all parameters to compare are consistent
	foreach $line (@pass_req_data) {

		# Ignore comments
		if ( $line =~ /^\s*#.*$/ or $line =~ /^\s*$/ ) { next; }

		my @data = split( /;/, $line );
		my $name = trim( $data[0] );
		$type{$name} = trim( $data[1] );
		if ( trim( $data[1] ) eq "Range" ) {
			$min_threshold{$name} = trim( $data[2] );
			$max_threshold{$name} = trim( $data[3] );
		} elsif (trim( $data[1] ) eq "RangeAbs") {
			$min_threshold{$name} = trim( $data[2] );
			$max_threshold{$name} = trim( $data[3] );
			$abs_diff_threshold{$name} = trim( $data[4] ); #Third element is absolute threshold
        } elsif (trim( $data[1] ) eq "Equal") {
            #Pass
        } else {
			print "[ERROR] $name has no comparison check specified (e.g. Range, RangeAbs, Equal).\n";
            $failed += 1;
			return $failed;
        }

		#Ensure item is in the first file
		if ( !grep { $_ eq $name } @second_test_params ) {
                    if ($is_golden){
                        print "[ERROR] $name is not in the golden results file.\n";
                    }else{
                        print "[ERROR] $name is not in the second parse file.\n";
                    }
                    $failed += 1;
		}

		# Ensure item is in new results
		if ( !grep { $_ eq $name } @first_test_params ) {
		    if ($is_golden){
                        print "[ERROR] $name is not in the results file.\n";
                    }else{
                        print "[ERROR] $name is not in the first parse file.\n";
                    }
                    $failed += 1;
		}

		push( @params, $name );
	}

	##############################################################
	# Compare first file data data with second file data
	##############################################################
	if ( ( scalar @first_test_data ) != ( scalar @second_test_data ) ) {
		print
		  "[ERROR] Different number of entries in the two files.\n";
          $failed += 1;
	}

	# Iterate through each line of the test results data and compare with the golden data
	foreach $line (@first_test_data) {
		my @first_file_line   = split( /\t/, $line );
		my @second_file_line = split( /\t/, shift @second_test_data );

        my $second_file_arch = trim(@second_file_line[0]);
        my $second_file_circuit = trim(@second_file_line[1]);
        my $first_file_arch = trim(@first_file_line[0]);
        my $first_file_circuit = trim(@first_file_line[1]);

		if (   ( $first_file_circuit ne $first_file_circuit )
			or ( $first_file_arch ne $first_file_arch ) ) {
            if ($is_golden){
                print "[ERROR] Circuit/Architecture mismatch between golden results ($second_file_arch/$second_file_circuit) and result ($first_file_arch/$first_file_circuit).\n";
            } else{
                print "[ERROR] Circuit/Architecture mismatch between first result file ($first_file_arch/$first_file_circuit) and second result fule ($second_file_arch/$second_file_circuit).\n";
            }
            $failed += 1;
			return $failed;
		}
		my $circuitarch = "$first_file_arch/$first_file_circuit";

		# Check each parameter where the type determines what to check for
		foreach my $value (@params) {
			my $first_file_index = List::Util::first { $first_test_params[$_] eq $value } 0 .. $#first_test_params;
			my $second_file_index = List::Util::first { $second_test_params[$_] eq $value } 0 .. $#second_test_params;
			my $first_file_value   = trim(@first_file_line[$first_file_index]);
			my $second_file_value = trim(@second_file_line[$second_file_index]);


			if ( $type{$value} eq "Range" or $type{$value} eq "RangeAbs" ) {
                my $abs_diff = abs($first_file_value - $second_file_value);
                my $ratio;
                if ($second_file_value == 0) {
                    $ratio = "inf";
                } else {
                    $ratio = $first_file_value / $second_file_value;
                }

                if($verbose) {
                    print "\tParam: $value\n";
                    print "\t\tTest: $first_file_value\n";
                    print "\t\tGolden Value: $second_file_value\n";
                    print "\t\tRatio: $ratio\n";
                    print "\t\tAbsDiff $abs_diff\n";
                }

                if (    exists $abs_diff_threshold{$value}
                    and $abs_diff <= $abs_diff_threshold{$value}) {
                    #Within absolute threshold
                    next;
                }

                if (    $ratio >= $min_threshold{$value}
                    and $ratio <= $max_threshold{$value}) {
                    #Within relative thershold  
                    next;
                }

                if ($first_file_value == $second_file_value) {
                    #Equal (e.g. both zero)
                    next;
                }

                if (    $first_file_value eq 'nan'
                    and $second_file_value eq 'nan') {
                    #Both literal Not-a-Numbers
                    next;
                }

                #Beyond absolute and relative thresholds
                if ($is_golden){
                    print
                        "[Fail] \n $circuitarch $value: golden = $second_file_value result = $first_file_value\n";
                }else{
                    print
                        "[Fail] \n $circuitarch $value: first result = $first_file_value second result = $second_file_value\n";
                }
                $failed += 1;
			} elsif ($type{$value} eq "Equal") {
				if ( $first_file_value ne $second_file_value ) {
                    if ($is_golden) {
                        print "[Fail] \n $circuitarch $value: golden = $second_file_value result = $first_file_value\n";
                    } else {
                        print "[Fail] \n $circuitarch $value: first result = $first_file_value second result = $second_file_value\n";
                    }
					$failed += 1;
				}
			} else {
				# If the check type is unknown
                $failed += 1;
                print "[Fail] \n $circuitarch $value: unrecognized check type '$type{$value}' (e.g. Range, RangeAbs, Equal)\n";

			}
		}
	}

	if ($failed == 0) {
		print "[Pass]\n";
	}
    return $failed;
}

sub trim() {
	my $string = shift;
	$string =~ s/^\s+//;
	$string =~ s/\s+$//;
	return $string;
}

sub expand_user_path {
	my $str = shift;
	$str =~ s/^~\//$ENV{"HOME"}\//;
	return $str;
}

sub get_important_file {
    my $task_path = shift;
    my $vtr_flow_path = shift;
    my $file = shift;
	if ( -e "$task_path/config/$file" ) {
		return "$task_path/config/$file";
	}
	elsif ( -e "$vtr_flow_path/parse/parse_config/$file" ) {
		return "$vtr_flow_path/parse/parse_config/$file";
	}
	elsif ( -e "$vtr_flow_path/parse/qor_config/$file" ) {
	    return "$vtr_flow_path/parse/qor_config/$file";
    }
	elsif ( $file !~ /^\/.*/ ) {
		die "Important file does not exist ($file)";
	}
}