ODIN_II/verify_odin.sh - third_party/vtr-verilog-to-routing - Git at Google

 #!/bin/bash
 #1
 trap ctrl_c INT SIGINT SIGTERM
 SHELL=/bin/bash

 QUIT=0

 INPUT=$@

 BASE_DIR="regression_test/benchmark"
 TEST_DIR_LIST=$(find regression_test/benchmark -mindepth 1 -maxdepth 1 -type d | cut -d '/' -f 3 | tr '\n' ' ')

 #include more generic names here for better vector generation
 HOLD_LOW_RESET="-L reset rst"
 HOLD_HIGH_WE="-H we"

 HOLD_PARAM="${HOLD_LOW_RESET} ${HOLD_HIGH_WE}"

 #if you want to pass in a new adder definition file
 ADDER_DEFINITION="--adder_type default"

 #if you want to change the default number of vectors to generate
 GENERATE_VECTOR_COUNT="-g 10"

 #if you want to change the default number of vectors to generate
 REGEN_VECTOR_CMD="--best_coverage -g 100"

 DEFAULT_ARCH="../libs/libarchfpga/arch/sample_arch.xml"

 MEM_ARCH="../vtr_flow/arch/timing/k6_N10_mem32K_40nm.xml"

 SMALL_ARCH_SWEEP="\
 ../vtr_flow/arch/timing/k6_N10_mem32K_40nm.xml \
 ../libs/libarchfpga/arch/sample_arch.xml \
 ../vtr_flow/arch/timing/k6_frac_N10_mem32K_40nm.xml"

 FULL_ARCH_SWEEP=$(find ../vtr_flow/arch/timing -maxdepth 1 | grep xml)

 DEFAULT_CMD_PARAM="${ADDER_DEFINITION}"

 EXEC="./wrapper_odin.sh"

 FAILURE=0

 new_run=regression_test/run001

 NB_OF_PROC=1
 REGENERATE_OUTPUT=0
 REGENERATE_BENCH=0
 TEST_TYPE=""

 TIME_LIMIT="1200s"

 USING_LOW_RESSOURCE=""

 function help() {

 printf "
 Called program with $INPUT

 Usage: ./verify_odin
 			--test [test name]    * test name is one of ( ${TEST_DIR_LIST}full_suite vtr_basic vtr_strong pre_commit )
 			--generate_bench      * generate input and output vector for test
 			--generate_output     * generate output vector for test given its input vector
 			--clean               * clean temporary directory
 			--nb_of_process [n]   * n = nb of process requested to be used
 			--limit_ressource     * force higher nice value and set hard limit for hardware memory to force swap more ***not always respected by system
 "
 }

 function config_help() {
 printf "
 config.txt expects a single line of argument wich can be one of:
 			--custom_args_file
 			--arch_list	[list_name]*
 			                *memories        use VTR k6_N10_mem32k architecture
 			                *small_sweep     use a small set of timing architecture
 			                *full_sweep  	 sweep the whole vtr directory *** WILL FAIL ***
 			                *default         use the sample_arch.xml
 			--simulate                       request simulation to be ran
 			--no_threading                   do not use multithreading for this test ** useful if you have large test **
 "
 }

 function get_current_time() {
 	echo $(date +%s%3N)
 }

 #1 start #2 end
 function print_time_since() {
 	BEGIN=$1
 	NOW=`get_current_time`
 	TIME_TO_RUN=$(( ${NOW} - ${BEGIN} ))

 	Mili=$(( ${TIME_TO_RUN} %1000 ))
 	Sec=$(( ( ${TIME_TO_RUN} /1000 ) %60 ))
 	Min=$(( ( ( ${TIME_TO_RUN} /1000 ) /60 ) %60 ))
 	Hour=$(( ( ( ${TIME_TO_RUN} /1000 ) /60 ) /60 ))

 	echo "ran test in: $Hour:$Min:$Sec.$Mili"
 }

 function init_temp() {
 	last_run=$(find regression_test/run* -maxdepth 0 -type d 2>/dev/null | tail -1 )
 	if [ "_${last_run}" != "_" ]
 	then
 		last_run_id=${last_run##regression_test/run}
 		n=$(echo $last_run_id | awk '{print $0 + 1}')
 		new_run=regression_test/run$(printf "%03d" $n)
 	fi
 	echo "running benchmark @${new_run}"
 	mkdir -p ${new_run}
 }

 function cleanup_temp() {
 	for runs in regression_test/run*
 	do
 		rm -Rf ${runs}
 	done
 }

 function mv_failed() {
 	failed_dir=$1
 	log_file="${failed_dir}.log"

 	if [ -e ${log_file} ]
 	then
 		echo "Failed benchmark have been move to ${failed_dir}"
 		for failed_benchmark in $(cat ${log_file})
 		do
 			parent_dir=$(dirname ${failed_dir}/${failed_benchmark})
 			mkdir -p ${parent_dir}
 			mv ${new_run}/${failed_benchmark} ${parent_dir}
 			FAILURE=$(( ${FAILURE} + 1 ))
 		done
 		cat ${log_file} >> ${new_run}/test_failures.log
 		rm -f ${log_file}
 	fi
 }

 function exit_program() {

 	if [ "_${FAILURE}" != "_0" ]
 	then
 		echo "Failed ${FAILURE} benchmarks"
 		echo "View Failure log in ${new_run}/test_failures.log"

 	else
 		echo "no run failure!"
 	fi

 	exit ${FAILURE}
 }

 function ctrl_c() {
 	QUIT=1
 	while [ "${QUIT}" != "0" ]
 	do
 		echo "** REGRESSION TEST EXITED FORCEFULLY **"
 		jobs -p | xargs kill &> /dev/null
 		pkill odin_II &> /dev/null
 		pkill ${EXEC} &> /dev/null
 		#should be dead by now
 		exit 120
 	done
 }

 function sim() {

 	####################################
 	# parse the function commands passed
 	with_custom_args="0"
 	arch_list="no_arch"
 	with_sim="0"
 	threads=${NB_OF_PROC}

 	if [ ! -e "$1" ]; then
 		echo "invalid benchmark directory passed to simulation function $1"
 		ctrl_c
 	fi
 	benchmark_dir="$1"
 	shift

 	while [[ "$#" > 0 ]]
 	do
 		case $1 in
 			--custom_args_file)
 				with_custom_args=1
 				;;

 			--arch_list)
 				case $2 in
 					memories)
 						arch_list="${MEM_ARCH}"
 						;;

 					small_sweep)
 						arch_list="${SMALL_ARCH_SWEEP}"
 						;;

 					full_sweep)
 						arch_list="${FULL_ARCH_SWEEP}"
 						;;

 					default)
 						arch_list="${DEFAULT_ARCH}"
 						;;
 					*)
 						;;
 				esac
 				shift
 				;;

 			--simulate)
 				with_sim=1
 				;;

 			--no_threading)
 				echo "This test will not be multithreaded"
 				threads="1"
 				;;

 			*)
 				echo "Unknown internal parameter passed: $1"
 				config_help
 				ctrl_c
 				;;
 		esac
 		shift
 	done

 	###########################################
 	# run custom benchmark
 	bench_type=${benchmark_dir##*/}
 	echo " BENCHMARK IS: ${bench_type}"

 	if [ "_${with_custom_args}" == "_1" ]; then

 		global_odin_failure="${new_run}/odin_failures"

 		for dir in ${benchmark_dir}/*
 		do
 			if [ -e ${dir}/odin.args ]; then
 				test_name=${dir##*/}
 				TEST_FULL_REF="${bench_type}/${test_name}"

 				DIR="${new_run}/${bench_type}/$test_name"
 				blif_file="${DIR}/odin.blif"


 				#build commands
 				mkdir -p $DIR
 				wrapper_odin_command="./wrapper_odin.sh
 											--log_file ${DIR}/odin.log
 											--test_name ${TEST_FULL_REF}
 											--failure_log ${global_odin_failure}.log
 											--time_limit ${TIME_LIMIT}
 											${USING_LOW_RESSOURCE}
 											${RUN_WITH_VALGRIND}"

 				odin_command="${DEFAULT_CMD_PARAM}
 								$(cat ${dir}/odin.args | tr '\n' ' ')
 								-o ${blif_file}
 								-sim_dir ${DIR}"

 				echo $(echo "${wrapper_odin_command} ${odin_command}" | tr '\n' ' ' | tr -s ' ' ) > ${DIR}/odin_param
 			fi
 		done

 		#run the custon command
 		echo " ========= Synthesizing Circuits"
 		find ${new_run}/${bench_type}/ -name odin_param | xargs -n1 -P$threads -I test_cmd ${SHELL} -c '$(cat test_cmd)'
 		mv_failed ${global_odin_failure}

 	############################################
 	# run benchmarks
 	else

 		global_synthesis_failure="${new_run}/synthesis_failures"
 		global_simulation_failure="${new_run}/simulation_failures"

 		for benchmark in ${benchmark_dir}/*.v
 		do
 			basename=${benchmark%.v}
 			test_name=${basename##*/}

 			input_vector_file="${basename}_input"
 			output_vector_file="${basename}_output"

 			for arches in ${arch_list}
 			do

 				arch_cmd=""
 				if [ -e ${arches} ]
 				then
 					arch_cmd="-a ${arches}"
 				fi

 				arch_basename=${arches%.xml}
 				arch_name=${arch_basename##*/}

 				TEST_FULL_REF="${bench_type}/${test_name}/${arch_name}"

 				DIR="${new_run}/${TEST_FULL_REF}"
 				blif_file="${DIR}/odin.blif"


 				#build commands
 				mkdir -p $DIR

 				wrapper_synthesis_command="./wrapper_odin.sh
 											--log_file ${DIR}/synthesis.log
 											--test_name ${TEST_FULL_REF}
 											--failure_log ${global_synthesis_failure}.log
 											--time_limit ${TIME_LIMIT}
 											${USING_LOW_RESSOURCE}
 											${RUN_WITH_VALGRIND}"

 				synthesis_command="${DEFAULT_CMD_PARAM}
 									${arch_cmd}
 									-V ${benchmark}
 									-o ${blif_file}
 									-sim_dir ${DIR}"

 				echo $(echo "${wrapper_synthesis_command} ${synthesis_command}"  | tr '\n' ' ' | tr -s ' ') > ${DIR}/cmd_param

 				if [ "_$with_sim" == "_1" ] || [ -e ${input_vector_file} ]
 				then
 					#force trigger simulation if input file exist
 					with_sim="1"

 					wrapper_simulation_command="./wrapper_odin.sh
 											--log_file ${DIR}/simulation.log
 											--test_name ${TEST_FULL_REF}
 											--failure_log ${global_simulation_failure}.log
 											--time_limit ${TIME_LIMIT}
 											${USING_LOW_RESSOURCE}
 											${RUN_WITH_VALGRIND}"

 					simulation_command="${DEFAULT_CMD_PARAM}
 											${arch_cmd}
 											-b ${blif_file}
 											-sim_dir ${DIR}
 											${HOLD_PARAM}"

 					if [ "_$REGENERATE_BENCH" == "_1" ]; then
 						simulation_command="${simulation_command} ${REGEN_VECTOR_CMD}"

 					elif [ -e ${input_vector_file} ]; then
 						simulation_command="${simulation_command} -t ${input_vector_file}"

 						if [ "_$REGENERATE_OUTPUT" != "_1" ] && [ -e ${output_vector_file} ]; then
 							simulation_command="${simulation_command} -T ${output_vector_file}"
 						fi

 					else
 						simulation_command="${simulation_command} ${GENERATE_VECTOR_COUNT}"

 					fi

 					echo $(echo "${wrapper_simulation_command} ${simulation_command}" | tr '\n' ' ' | tr -s ' ') > ${DIR}/sim_param
 				fi
 			done
 		done

 		#synthesize the circuits
 		echo " ========= Synthesizing Circuits"
 		find ${new_run}/${bench_type}/ -name cmd_param | xargs -n1 -P$threads -I test_cmd ${SHELL} -c '$(cat test_cmd)'
 		mv_failed ${global_synthesis_failure}

 		if [ "_$with_sim" == "_1" ]
 		then
 			#run the simulation
 			echo " ========= Simulating Circuits"
 			find ${new_run}/${bench_type}/ -name sim_param | xargs -n1 -P$threads -I sim_cmd ${SHELL} -c '$(cat sim_cmd)'
 			mv_failed ${global_simulation_failure}
 		fi

 	fi


 }

 function parse_args() {
 	while [[ "$#" > 0 ]]
 	do
 		case $1 in
 			-h|--help)
 				help
 				exit_program
 				;;

 			--generate_output)
 				if [ $REGENERATE_BENCH != "0" ] || [ $REGENERATE_OUTPUT != "0" ]
 				then
 					echo "can only specify one of --generate_output or --generate_bench"
 					help
 					ctrl_c
 				fi
 				REGENERATE_OUTPUT=1
 				echo "regenerating output vector for test given predefined input"
 				;;

 			--generate_bench)
 				if [ $REGENERATE_BENCH != "0" ] || [ $REGENERATE_OUTPUT != "0" ]
 				then
 					echo "can only specify one of --generate_output or --generate_bench"
 					help
 					ctrl_c
 				fi
 				REGENERATE_BENCH=1
 				echo "regenerating input and output vector for test"
 				;;

 			--limit_ressource)
 				USING_LOW_RESSOURCE="--limit_ressource"
 				echo "limiting ressources for benchmark, this can help with small hardware"
 				;;

 			--clean)
 				cleanup_temp
 				;;

 			--nb_of_process)
 				if [ $NB_OF_PROC != "1" ]
 				then
 					echo "can only specify the number of processes once"
 					help
 					ctrl_c
 				fi

 				if [[ "$2" -gt "0" ]]
 				then
 					NB_OF_PROC=$2
 					echo "Running benchmark on $NB_OF_PROC processes"
 				fi
 				shift
 				;;
 			--valgrind)
 				RUN_WITH_VALGRIND="--valgrind"
 				;;

 			--test)
 				if [ "_$TEST_TYPE" != "_" ]
 				then
 					echo "can only specify one test for this script"
 					help
 					ctrl_c
 				fi

 				TEST_TYPE=$2
 				shift
 				;;

 			*)
 				echo "Unknown parameter passed: $1"
 				help
 				ctrl_c
 				;;
 		esac
 		shift
 	done
 }

 RUN_LIST=(
 "operators"
 "arch"
 "other"
 "micro"
 "syntax"
 "full"
 "large"
 )

 function run_all() {
 	for test_dir in ${RUN_LIST[@]}; do
 		sim ${BASE_DIR}/${test_dir} $(cat ${BASE_DIR}/${test_dir}/config.txt)
 	done
 }
 #########################################################
 #	START HERE

 START=`get_current_time`

 parse_args $INPUT

 if [ "_${TEST_TYPE}" == "_" ]; then
 	echo "No input test!"
 	help
 	print_time_since $START
 	exit_program
 fi


 echo "Benchmark is: $TEST_TYPE"

 init_temp
 case $TEST_TYPE in

 	"full_suite")
 		run_all
 		;;

 	"vtr_basic")
 		cd ..
 		/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_basic
 		cd ODIN_II
 		;;

 	"vtr_strong")
 		cd ..
 		/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_strong
 		cd ODIN_II
 		;;

 	"pre_commit")
 		run_all
 		cd ..
 		/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_basic
 		/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_strong
 		cd ODIN_II
 		;;

 	*)
 		if [ ! -e ${BASE_DIR}/${TEST_TYPE} ]; then
 			echo "${BASE_DIR}/${TEST_TYPE} Not Found! exiting."
 			config_help
 			ctrl_c
 		fi

 		if [ ! -e ${BASE_DIR}/${TEST_TYPE}/config.txt ]; then
 			echo "no config file found in the directory."
 			echo "please make sure a config.txt exist"
 			config_help
 			ctrl_c
 		fi

 		sim ${BASE_DIR}/${TEST_TYPE} $(cat ${BASE_DIR}/${TEST_TYPE}/config.txt)
 		;;
 esac

 print_time_since $START

 exit_program
 ### end here
	#!/bin/bash
	#1
	trap ctrl_c INT SIGINT SIGTERM
	SHELL=/bin/bash

	QUIT=0

	INPUT=$@

	BASE_DIR="regression_test/benchmark"
	TEST_DIR_LIST=$(find regression_test/benchmark -mindepth 1 -maxdepth 1 -type d \| cut -d '/' -f 3 \| tr '\n' ' ')

	#include more generic names here for better vector generation
	HOLD_LOW_RESET="-L reset rst"
	HOLD_HIGH_WE="-H we"

	HOLD_PARAM="${HOLD_LOW_RESET} ${HOLD_HIGH_WE}"

	#if you want to pass in a new adder definition file
	ADDER_DEFINITION="--adder_type default"

	#if you want to change the default number of vectors to generate
	GENERATE_VECTOR_COUNT="-g 10"

	#if you want to change the default number of vectors to generate
	REGEN_VECTOR_CMD="--best_coverage -g 100"

	DEFAULT_ARCH="../libs/libarchfpga/arch/sample_arch.xml"

	MEM_ARCH="../vtr_flow/arch/timing/k6_N10_mem32K_40nm.xml"

	SMALL_ARCH_SWEEP="\
	../vtr_flow/arch/timing/k6_N10_mem32K_40nm.xml \
	../libs/libarchfpga/arch/sample_arch.xml \
	../vtr_flow/arch/timing/k6_frac_N10_mem32K_40nm.xml"

	FULL_ARCH_SWEEP=$(find ../vtr_flow/arch/timing -maxdepth 1 \| grep xml)

	DEFAULT_CMD_PARAM="${ADDER_DEFINITION}"

	EXEC="./wrapper_odin.sh"

	FAILURE=0

	new_run=regression_test/run001

	NB_OF_PROC=1
	REGENERATE_OUTPUT=0
	REGENERATE_BENCH=0
	TEST_TYPE=""

	TIME_LIMIT="1200s"

	USING_LOW_RESSOURCE=""

	function help() {

	printf "
	Called program with $INPUT

	Usage: ./verify_odin
	--test [test name] * test name is one of ( ${TEST_DIR_LIST}full_suite vtr_basic vtr_strong pre_commit )
	--generate_bench * generate input and output vector for test
	--generate_output * generate output vector for test given its input vector
	--clean * clean temporary directory
	--nb_of_process [n] * n = nb of process requested to be used
	--limit_ressource * force higher nice value and set hard limit for hardware memory to force swap more ***not always respected by system
	"
	}

	function config_help() {
	printf "
	config.txt expects a single line of argument wich can be one of:
	--custom_args_file
	--arch_list [list_name]*
	*memories use VTR k6_N10_mem32k architecture
	*small_sweep use a small set of timing architecture
	full_sweep sweep the whole vtr directory WILL FAIL *
	*default use the sample_arch.xml
	--simulate request simulation to be ran
	--no_threading do not use multithreading for this test useful if you have large test
	"
	}

	function get_current_time() {
	echo $(date +%s%3N)
	}

	#1 start #2 end
	function print_time_since() {
	BEGIN=$1
	NOW=`get_current_time`
	TIME_TO_RUN=$(( ${NOW} - ${BEGIN} ))

	Mili=$(( ${TIME_TO_RUN} %1000 ))
	Sec=$(( ( ${TIME_TO_RUN} /1000 ) %60 ))
	Min=$(( ( ( ${TIME_TO_RUN} /1000 ) /60 ) %60 ))
	Hour=$(( ( ( ${TIME_TO_RUN} /1000 ) /60 ) /60 ))

	echo "ran test in: $Hour:$Min:$Sec.$Mili"
	}

	function init_temp() {
	last_run=$(find regression_test/run* -maxdepth 0 -type d 2>/dev/null \| tail -1 )
	if [ "_${last_run}" != "_" ]
	then
	last_run_id=${last_run##regression_test/run}
	n=$(echo $last_run_id \| awk '{print $0 + 1}')
	new_run=regression_test/run$(printf "%03d" $n)
	fi
	echo "running benchmark @${new_run}"
	mkdir -p ${new_run}
	}

	function cleanup_temp() {
	for runs in regression_test/run*
	do
	rm -Rf ${runs}
	done
	}

	function mv_failed() {
	failed_dir=$1
	log_file="${failed_dir}.log"

	if [ -e ${log_file} ]
	then
	echo "Failed benchmark have been move to ${failed_dir}"
	for failed_benchmark in $(cat ${log_file})
	do
	parent_dir=$(dirname ${failed_dir}/${failed_benchmark})
	mkdir -p ${parent_dir}
	mv ${new_run}/${failed_benchmark} ${parent_dir}
	FAILURE=$(( ${FAILURE} + 1 ))
	done
	cat ${log_file} >> ${new_run}/test_failures.log
	rm -f ${log_file}
	fi
	}

	function exit_program() {

	if [ "_${FAILURE}" != "_0" ]
	then
	echo "Failed ${FAILURE} benchmarks"
	echo "View Failure log in ${new_run}/test_failures.log"

	else
	echo "no run failure!"
	fi

	exit ${FAILURE}
	}

	function ctrl_c() {
	QUIT=1
	while [ "${QUIT}" != "0" ]
	do
	echo " REGRESSION TEST EXITED FORCEFULLY "
	jobs -p \| xargs kill &> /dev/null
	pkill odin_II &> /dev/null
	pkill ${EXEC} &> /dev/null
	#should be dead by now
	exit 120
	done
	}

	function sim() {

	####################################
	# parse the function commands passed
	with_custom_args="0"
	arch_list="no_arch"
	with_sim="0"
	threads=${NB_OF_PROC}

	if [ ! -e "$1" ]; then
	echo "invalid benchmark directory passed to simulation function $1"
	ctrl_c
	fi
	benchmark_dir="$1"
	shift

	while [[ "$#" > 0 ]]
	do
	case $1 in
	--custom_args_file)
	with_custom_args=1
	;;

	--arch_list)
	case $2 in
	memories)
	arch_list="${MEM_ARCH}"
	;;

	small_sweep)
	arch_list="${SMALL_ARCH_SWEEP}"
	;;

	full_sweep)
	arch_list="${FULL_ARCH_SWEEP}"
	;;

	default)
	arch_list="${DEFAULT_ARCH}"
	;;
	*)
	;;
	esac
	shift
	;;

	--simulate)
	with_sim=1
	;;

	--no_threading)
	echo "This test will not be multithreaded"
	threads="1"
	;;

	*)
	echo "Unknown internal parameter passed: $1"
	config_help
	ctrl_c
	;;
	esac
	shift
	done

	###########################################
	# run custom benchmark
	bench_type=${benchmark_dir##*/}
	echo " BENCHMARK IS: ${bench_type}"

	if [ "_${with_custom_args}" == "_1" ]; then

	global_odin_failure="${new_run}/odin_failures"

	for dir in ${benchmark_dir}/*
	do
	if [ -e ${dir}/odin.args ]; then
	test_name=${dir##*/}
	TEST_FULL_REF="${bench_type}/${test_name}"

	DIR="${new_run}/${bench_type}/$test_name"
	blif_file="${DIR}/odin.blif"


	#build commands
	mkdir -p $DIR
	wrapper_odin_command="./wrapper_odin.sh
	--log_file ${DIR}/odin.log
	--test_name ${TEST_FULL_REF}
	--failure_log ${global_odin_failure}.log
	--time_limit ${TIME_LIMIT}
	${USING_LOW_RESSOURCE}
	${RUN_WITH_VALGRIND}"

	odin_command="${DEFAULT_CMD_PARAM}
	$(cat ${dir}/odin.args \| tr '\n' ' ')
	-o ${blif_file}
	-sim_dir ${DIR}"

	echo $(echo "${wrapper_odin_command} ${odin_command}" \| tr '\n' ' ' \| tr -s ' ' ) > ${DIR}/odin_param
	fi
	done

	#run the custon command
	echo " ========= Synthesizing Circuits"
	find ${new_run}/${bench_type}/ -name odin_param \| xargs -n1 -P$threads -I test_cmd ${SHELL} -c '$(cat test_cmd)'
	mv_failed ${global_odin_failure}

	############################################
	# run benchmarks
	else

	global_synthesis_failure="${new_run}/synthesis_failures"
	global_simulation_failure="${new_run}/simulation_failures"

	for benchmark in ${benchmark_dir}/*.v
	do
	basename=${benchmark%.v}
	test_name=${basename##*/}

	input_vector_file="${basename}_input"
	output_vector_file="${basename}_output"

	for arches in ${arch_list}
	do

	arch_cmd=""
	if [ -e ${arches} ]
	then
	arch_cmd="-a ${arches}"
	fi

	arch_basename=${arches%.xml}
	arch_name=${arch_basename##*/}

	TEST_FULL_REF="${bench_type}/${test_name}/${arch_name}"

	DIR="${new_run}/${TEST_FULL_REF}"
	blif_file="${DIR}/odin.blif"


	#build commands
	mkdir -p $DIR

	wrapper_synthesis_command="./wrapper_odin.sh
	--log_file ${DIR}/synthesis.log
	--test_name ${TEST_FULL_REF}
	--failure_log ${global_synthesis_failure}.log
	--time_limit ${TIME_LIMIT}
	${USING_LOW_RESSOURCE}
	${RUN_WITH_VALGRIND}"

	synthesis_command="${DEFAULT_CMD_PARAM}
	${arch_cmd}
	-V ${benchmark}
	-o ${blif_file}
	-sim_dir ${DIR}"

	echo $(echo "${wrapper_synthesis_command} ${synthesis_command}" \| tr '\n' ' ' \| tr -s ' ') > ${DIR}/cmd_param

	if [ "_$with_sim" == "_1" ] \|\| [ -e ${input_vector_file} ]
	then
	#force trigger simulation if input file exist
	with_sim="1"

	wrapper_simulation_command="./wrapper_odin.sh
	--log_file ${DIR}/simulation.log
	--test_name ${TEST_FULL_REF}
	--failure_log ${global_simulation_failure}.log
	--time_limit ${TIME_LIMIT}
	${USING_LOW_RESSOURCE}
	${RUN_WITH_VALGRIND}"

	simulation_command="${DEFAULT_CMD_PARAM}
	${arch_cmd}
	-b ${blif_file}
	-sim_dir ${DIR}
	${HOLD_PARAM}"

	if [ "_$REGENERATE_BENCH" == "_1" ]; then
	simulation_command="${simulation_command} ${REGEN_VECTOR_CMD}"

	elif [ -e ${input_vector_file} ]; then
	simulation_command="${simulation_command} -t ${input_vector_file}"

	if [ "_$REGENERATE_OUTPUT" != "_1" ] && [ -e ${output_vector_file} ]; then
	simulation_command="${simulation_command} -T ${output_vector_file}"
	fi

	else
	simulation_command="${simulation_command} ${GENERATE_VECTOR_COUNT}"

	fi

	echo $(echo "${wrapper_simulation_command} ${simulation_command}" \| tr '\n' ' ' \| tr -s ' ') > ${DIR}/sim_param
	fi
	done
	done

	#synthesize the circuits
	echo " ========= Synthesizing Circuits"
	find ${new_run}/${bench_type}/ -name cmd_param \| xargs -n1 -P$threads -I test_cmd ${SHELL} -c '$(cat test_cmd)'
	mv_failed ${global_synthesis_failure}

	if [ "_$with_sim" == "_1" ]
	then
	#run the simulation
	echo " ========= Simulating Circuits"
	find ${new_run}/${bench_type}/ -name sim_param \| xargs -n1 -P$threads -I sim_cmd ${SHELL} -c '$(cat sim_cmd)'
	mv_failed ${global_simulation_failure}
	fi

	fi


	}

	function parse_args() {
	while [[ "$#" > 0 ]]
	do
	case $1 in
	-h\|--help)
	help
	exit_program
	;;

	--generate_output)
	if [ $REGENERATE_BENCH != "0" ] \|\| [ $REGENERATE_OUTPUT != "0" ]
	then
	echo "can only specify one of --generate_output or --generate_bench"
	help
	ctrl_c
	fi
	REGENERATE_OUTPUT=1
	echo "regenerating output vector for test given predefined input"
	;;

	--generate_bench)
	if [ $REGENERATE_BENCH != "0" ] \|\| [ $REGENERATE_OUTPUT != "0" ]
	then
	echo "can only specify one of --generate_output or --generate_bench"
	help
	ctrl_c
	fi
	REGENERATE_BENCH=1
	echo "regenerating input and output vector for test"
	;;

	--limit_ressource)
	USING_LOW_RESSOURCE="--limit_ressource"
	echo "limiting ressources for benchmark, this can help with small hardware"
	;;

	--clean)
	cleanup_temp
	;;

	--nb_of_process)
	if [ $NB_OF_PROC != "1" ]
	then
	echo "can only specify the number of processes once"
	help
	ctrl_c
	fi

	if [[ "$2" -gt "0" ]]
	then
	NB_OF_PROC=$2
	echo "Running benchmark on $NB_OF_PROC processes"
	fi
	shift
	;;
	--valgrind)
	RUN_WITH_VALGRIND="--valgrind"
	;;

	--test)
	if [ "_$TEST_TYPE" != "_" ]
	then
	echo "can only specify one test for this script"
	help
	ctrl_c
	fi

	TEST_TYPE=$2
	shift
	;;

	*)
	echo "Unknown parameter passed: $1"
	help
	ctrl_c
	;;
	esac
	shift
	done
	}

	RUN_LIST=(
	"operators"
	"arch"
	"other"
	"micro"
	"syntax"
	"full"
	"large"
	)

	function run_all() {
	for test_dir in ${RUN_LIST[@]}; do
	sim ${BASE_DIR}/${test_dir} $(cat ${BASE_DIR}/${test_dir}/config.txt)
	done
	}
	#########################################################
	# START HERE

	START=`get_current_time`

	parse_args $INPUT

	if [ "_${TEST_TYPE}" == "_" ]; then
	echo "No input test!"
	help
	print_time_since $START
	exit_program
	fi


	echo "Benchmark is: $TEST_TYPE"

	init_temp
	case $TEST_TYPE in

	"full_suite")
	run_all
	;;

	"vtr_basic")
	cd ..
	/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_basic
	cd ODIN_II
	;;

	"vtr_strong")
	cd ..
	/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_strong
	cd ODIN_II
	;;

	"pre_commit")
	run_all
	cd ..
	/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_basic
	/usr/bin/perl run_reg_test.pl -j $NB_OF_PROC vtr_reg_strong
	cd ODIN_II
	;;

	*)
	if [ ! -e ${BASE_DIR}/${TEST_TYPE} ]; then
	echo "${BASE_DIR}/${TEST_TYPE} Not Found! exiting."
	config_help
	ctrl_c
	fi

	if [ ! -e ${BASE_DIR}/${TEST_TYPE}/config.txt ]; then
	echo "no config file found in the directory."
	echo "please make sure a config.txt exist"
	config_help
	ctrl_c
	fi

	sim ${BASE_DIR}/${TEST_TYPE} $(cat ${BASE_DIR}/${TEST_TYPE}/config.txt)
	;;
	esac

	print_time_since $START

	exit_program
	### end here