Huawei_Technology
/
MindSpore-AKG
Not watched
1
0
Fork 0
Code
Releases 1 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 7da00a1f10
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7da00a1f10'
${ noResults }
MindSpore-AKG/tests/operators/case_run_mgr.sh

362 lines
12 kB
Raw Blame History 

  1. #!/bin/bash

  2. 

  3. # Copyright 2019 Huawei Technologies Co., Ltd

  4. #

  5. # Licensed under the Apache License, Version 2.0 (the "License");

  6. # you may not use this file except in compliance with the License.

  7. # You may obtain a copy of the License at

  8. #

  9. # http://www.apache.org/licenses/LICENSE-2.0

  10. #

  11. # Unless required by applicable law or agreed to in writing, software

  12. # distributed under the License is distributed on an "AS IS" BASIS,

  13. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  14. # See the License for the specific language governing permissions and

  15. # limitations under the License.

  16. 

  17. cd $(dirname $0)

  18. 

  19. . ../test_env.sh kc_air

  20. 

  21. export RANDOM_DATA_DISK_PATH=$(pwd)

  22. TVM_CASE_ROOT_HOME="${RANDOM_DATA_DISK_PATH}/.."

  23. export WRITE_TO_DISK=No

  24. python -c  "import tensorio;tensorio.random_data_to_disk(size=10485760, miu=[1, 0.5, 0.1], sigma=[0.1, 0.05, 0.01])"

  25. log_ftp_path="./"

  26. pipe_line_type=""

  27. pipe_line_index=0

  28. max_pipe_line=1

  29. all_case_run_flag="true"

  30. rpc_host=""

  31. rpc_port=0

  32. runtime_mode=""

  33. sub_pipe_flag=""

  34. 

  35. while getopts ":d:l:i:m:a:h:p:r:s:" opt

  36. do

  37.     case $opt in

  38.         d) # 日志路径

  39.         log_ftp_path=$OPTARG

  40.         ;;

  41.         l) # 流水线类型

  42.         pipe_line_type=$OPTARG

  43.         ;;

  44.         i) # 流水线索引，拆分时使用

  45.         pipe_line_index=$OPTARG

  46.         ;;

  47.         m) # 流水线最大数量，拆分时使用

  48.         max_pipe_line=$OPTARG

  49.         ;;

  50.         a) # 是否跑完全流水线标记

  51.         all_case_run_flag=$OPTARG

  52.         ;;

  53.         h)  # rpc_host

  54.         rpc_host=$OPTARG

  55.         ;;

  56.         p) # rpc_port

  57.         rpc_port=$OPTARG

  58.         ;;

  59.         r) # runtime_mode

  60.         runtime_mode=$OPTARG

  61.         ;;

  62.         s) # sub_pipe_flag

  63.         sub_pipe_flag=$OPTARG

  64.         ;;

  65.         ?)

  66.         echo "valid optarg"

  67.         exit 1;;

  68.     esac

  69. done

  70. 

  71. echo "log_ftp_path:${log_ftp_path}, pipe_line_type:${pipe_line_type}, pipe_line_index:${pipe_line_index}, max_pipe_line:${max_pipe_line}, sub_pipe_flag:${sub_pipe_flag}, all_case_run_flag:${all_case_run_flag}"

  72. 

  73. echo "RUNTIME_MODE:${RUNTIME_MODE}"

  74. 

  75. taskid=$(date +%s%N | md5sum | head -c 32)

  76. log_file_path="${log_ftp_path}/${taskid}/"

  77. mkdir -p "${log_file_path}"

  78. echo "log_file_path:${log_file_path}"

  79. 

  80. all_case_list_file=${log_file_path}/all_case_list_${pipe_line_type}_${pipe_line_index}_${taskid}.txt

  81. touch "${all_case_list_file}"

  82. case_result_file=${log_file_path}/case_result_${pipe_line_type}_${pipe_line_index}_${taskid}.csv

  83. touch "${case_result_file}"

  84. all_case_count_file=${log_file_path}/all_case_count_${pipe_line_type}_${pipe_line_index}_${taskid}.csv

  85. touch "${all_case_count_file}"

  86. 

  87. exit_flag=0

  88. 

  89. function exit_with_code()

  90. {

  91.     local function_name=$1

  92.     local ret=$2

  93.     local case_name=$3

  94.     local output_file=$4

  95.     if [[ "${ret}" != "0" && ${all_case_run_flag} == "false" ]] ; then

  96.         echo "${function_name}, ${case_name}, ${ret}, failed , exit"

  97.         exit_flag=1

  98.         [ -f "${output_file}" ] && cat "${output_file}"

  99.         exit ${exit_flag}

  100.     fi

  101. }

  102. 

  103. function get_case_list_by_file()

  104. {

  105. 

  106.     local path=$1

  107.     local attr=$2

  108.     old_path=$(pwd)

  109.     cd "${path}" || return

  110.     chmod 400 ./*.py

  111.     rm -rf "${all_case_list_file}"

  112.     touch "${all_case_list_file}"

  113.     local line_idx=0

  114.     local attr_flag=$(echo "${attr}" | awk '{print $2}')

  115.     for file_name in test_*.py

  116.     do

  117.         attr_flag_count=$(grep -c ".mark.${attr_flag}" "${file_name}")

  118.         if [[ ${attr_flag_count} -gt 0 ]]

  119.         then

  120.             line_res=$(( line_idx % max_pipe_line ))

  121.             ((line_idx++))

  122.             if [[ ${line_res} -eq ${pipe_line_index} ]]

  123.             then

  124.                 echo "${file_name%%.py*}" >> "${all_case_list_file}"

  125.             fi

  126.         fi

  127.     done

  128.     cd "${old_path}" || return

  129.     echo

  130.     cat "${all_case_list_file}"

  131. }

  132. 

  133. function get_case_list_by_args()

  134. {

  135.     local path=$1

  136.     local case_name=$2

  137.     local attr=$3

  138.     old_path=$(pwd)

  139.     cd "${path}" || return

  140.     chmod 400 "${case_name}.py"

  141.     rm -rf "${all_case_list_file}"

  142.     touch "${all_case_list_file}"

  143.     export CASE_ARG_ATTR="${attr}"

  144.     echo "attr:${attr}, CASE_ARG_ATTR:${CASE_ARG_ATTR}, case_name:${case_name}"

  145.     python -c "import ${case_name};${case_name}.print_args()" > "./tmp_case_list.txt" 2>&1

  146.     ret=$?

  147.     unset CASE_ARG_ATTR

  148.     exit_with_code "get_case_list_by_args" "${ret}" "NULL"  "./tmp_case_list.txt"

  149. 

  150.     local line_idx=0

  151.     cat ./tmp_case_list.txt

  152.     cat ./tmp_case_list.txt |grep "${case_name}&" > ./tmp_case_list_${pipe_line_type}_${pipe_line_index}_${taskid}.txt

  153. 

  154.     while read -r line

  155.     do

  156.         line_res=$(( line_idx % max_pipe_line ))

  157.         ((line_idx++))

  158.         if [[ ${line_res} -eq ${pipe_line_index} ]] ;then

  159.             echo "${line}" >> "${all_case_list_file}"

  160.         fi

  161.     done < "./tmp_case_list_${pipe_line_type}_${pipe_line_index}_${taskid}.txt"

  162.     cd "${old_path}" || return

  163. }

  164. 

  165. function run_one_case()

  166. {

  167.     local path=$1

  168.     local attr=$2

  169.     local case_name=$3

  170.     local case_flag=$4

  171.     local test_index=$5

  172. 

  173.     old_path=$(pwd)

  174.     cd "${path}" || return

  175.     echo "$(date '+%Y-%m-%d %H:%M:%S') attr:${attr}, case_name:${case_name}, case_flag:${case_flag}, test_index:${test_index}"

  176.     chmod 400 "${case_name}.py"

  177.     start_case_time=$(date +%s)

  178.     pytest  "${attr}" -s "${case_name}.py"  > "./${case_name}-${case_flag}-${taskid}.log" 2>&1

  179.     ret=$?

  180.     end_case_time=$(date +%s)

  181.     time_ring=$(( end_case_time - start_case_time ))

  182.     result="succ"

  183.     if [[ ${ret} -ne 0 ]] ; then

  184.         result="fail"

  185.     fi

  186. 

  187.     grep "func_time_required" "./${case_name}-${case_flag}-${taskid}.log"

  188.     echo "${case_name}-${case_flag}, ${time_ring}"

  189. 

  190.     echo "${pipe_line_type}, ${sub_pipe_flag}, ${case_name}-${case_flag},${result},${case_name}-${case_flag}-${taskid}.log,${ret},${time_ring}" >> "${case_result_file}"

  191.     if [[ "x${result}" != "xsucc" ]] ;then

  192.         cd "${old_path}" || return

  193.         echo "${case_name}, ${case_flag}, ${ret}, failed "

  194. 	echo "################# ${case_name}-${case_flag}-${taskid}.log start ##################### "

  195.         cat  "${case_name}-${case_flag}-${taskid}.log"

  196. 	echo "################# ${case_name}-${case_flag}-${taskid}.log end   ##################### "

  197. 	if [[ "x${result}" == "xfail" ]] ;then

  198.             # 可预期错误

  199.             exit_with_code "run_one_case" ${ret} "${case_name}-${case_flag}" "NULL"

  200.         fi

  201.     fi

  202. 

  203.     cd "${old_path}" || return

  204.     return 0

  205. }

  206. 

  207. function run_operator_case_list()

  208. {

  209.     local path=$1

  210.     local attr=$2

  211.     get_case_list_by_file "${path}" "${attr}"

  212.     case_flag="daily"

  213.     old_path=$(pwd)

  214.     cd "${path}" || return

  215.     while read -r case_name

  216.     do

  217.         run_one_case "${path}" "${attr}" "${case_name}" "${case_flag}" "0"

  218.     done < "${all_case_list_file}"

  219.     cd "${old_path}" || return

  220. }

  221. 

  222. function run_net_case_list()

  223. {

  224.     local path=$1

  225.     local attr=$2

  226.     local case_name=$3

  227. 

  228.     if [[ "${RUNTIME_MODE}" == "rpc" ]]

  229.     then

  230.         attr="-m rpc"

  231.     elif [[ "${RUNTIME_MODE}" == "rpc_cloud" ]]

  232.     then

  233.         attr="-m rpc_cloud"

  234.     else

  235.         attr="-m level0"

  236.     fi

  237. 

  238.     old_path=$(pwd)

  239.     run_attr=$(echo "${attr}" | awk -F "=" '{print $2}')

  240.     get_case_list_by_args "${path}" "${case_name}" "${run_attr}"

  241.     cd "${path}" || return

  242.     while read -r line

  243.     do

  244.     	echo "${line}"

  245.         case_name=$(echo "${line}" | awk -F "&" '{print $1}')

  246.         test_index=$(echo "${line}" | awk -F "&" '{print $2}')

  247.         case_flag=$(echo "${line}" | awk -F "&" '{print $3}')

  248.         export TEST_INDEX=${test_index}

  249.         run_one_case "${path}" "${attr}" "${case_name}" "${case_flag}" "${test_index}"

  250.         unset TEST_INDEX

  251.     done < "${all_case_list_file}"

  252.     cd "${old_path}" || return

  253. }

  254. 

  255. function run_unittest_list()

  256. {

  257.     local path=$1

  258.     local attr=$2

  259.     local case_pipe=$3

  260.     old_path=$(pwd)

  261.     cd "${path}" || return

  262.     local case_file_list=("cce/test_bias_add.py" "pass/test_promote_if.py" "pass/test_sink_if.py" "pass/test_copy_propagation.py")

  263.     for case_name in "${case_file_list[@]}"

  264.     do

  265.         python "${case_name}" > "${case_name}.log" 2>&1

  266.         ret=$?

  267.         if [[ "${ret}" -ne "0" ]] ; then

  268.             echo "run unit case ${case_name} failed!!!"

  269.             cp -ar "${case_name}.log" "${log_file_path}"

  270.             result="fail"

  271.         else

  272.             result="succ"

  273.         fi

  274.         echo "${pipe_line_type}, ${sub_pipe_flag}, ${case_name},${result},${case_name}.log,${ret},0,null" >> "${case_result_file}"

  275.         exit_with_code "run_unittest_list" "${ret}" "${case_name}.log" "NULL"

  276.     done

  277.     cd "${old_path}" || return

  278. }

  279. 

  280. if [[ "${RUNTIME_MODE}" == "rpc" ]]

  281. then

  282.     run_attr="rpc"

  283. elif [[ "${RUNTIME_MODE}" == "rpc_cloud" ]]

  284. then

  285.     run_attr="rpc_cloud"

  286. else

  287.     run_attr="level0"

  288. fi

  289. 

  290. if [[ "${pipe_line_type}" == "vector_level0" ]]

  291. then

  292.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/vector" "-m level0"

  293. elif [[ "${pipe_line_type}" == "vector_level1" ]]

  294. then

  295.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/vector" "-m level1"

  296. elif [[ "${pipe_line_type}" == "vector_aic_model" ]]

  297. then

  298.     run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/vector" "-m aicmodel"

  299. elif [[ "${pipe_line_type}" == "vector_rpc_mini" ]]

  300. then

  301.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/vector" "-m rpc_mini"

  302. elif [[ "${pipe_line_type}" == "vector_rpc_cloud" ]]

  303. then

  304.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/vector" "-m rpc_cloud"

  305. elif [[ "${pipe_line_type}" == "cube_level0" ]]

  306. then

  307.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/cube" "-m level0"

  308. elif [[ "${pipe_line_type}" == "cube_level1" ]]

  309. then

  310.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/cube" "-m level1"

  311. elif [[ "${pipe_line_type}" == "cube_rpc_mini" ]]

  312. then

  313.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/cube" "-m rpc_mini"

  314. elif [[ "${pipe_line_type}" == "cube_rpc_cloud" ]]

  315. then

  316.      run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/cube" "-m rpc_cloud"

  317. elif [[ "${pipe_line_type}" == "bert_pipe" ]]

  318. then

  319.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_bert_all_001"

  320. elif [[ "${pipe_line_type}" == "ssd_pipe" ]]

  321. then

  322.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_ssd_all_001"

  323. elif [[ "${pipe_line_type}" == "reid_pipe" ]]

  324. then

  325.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_reid_all_001"

  326. elif [[ "${pipe_line_type}" == "resnet50_pipe" ]]

  327. then

  328.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_resnet50_all_001"

  329. elif [[ "${pipe_line_type}" == "alexnet_pipe" ]]

  330. then

  331.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_alexnet_all_001"

  332. elif [[ "${pipe_line_type}" == "lenet_pipe" ]]

  333. then

  334.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_lenet_all_001"

  335. elif [[ "${pipe_line_type}" == "autodiff_pipe" ]]

  336. then

  337.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_autodiff_all_001"

  338. elif [[ "${pipe_line_type}" == "allnet_pipe" ]]

  339. then

  340.     run_net_case_list "${TVM_CASE_ROOT_HOME}/perf_benchmark" "-m level0" "test_allnet_all_001"

  341. elif [[ "${pipe_line_type}" == "unittest_pipe" ]]

  342. then

  343.     run_unittest_list "${TVM_CASE_ROOT_HOME}/unittest" "-m level0" "unittest"

  344. elif [[ "${pipe_line_type}" == "dynamic_shape" ]]

  345. then

  346.     run_operator_case_list "${TVM_CASE_ROOT_HOME}/operators/dynamic_shape" "-m level0"

  347. else :

  348.     echo "not support ${pipe_line_type}"

  349.     exit_flag=1

  350.     exit ${exit_flag}

  351. fi

  352. 

  353. succ_case_count=$(< "${case_result_file}" awk -F "," '{print $4}' | grep -c "succ" )

  354. fail_case_count=$(< "${case_result_file}" awk -F "," '{print $4}' | grep -c "fail" )

  355. all_case_count=$(< "${case_result_file}" wc -l)

  356. 

  357. echo "${pipe_line_type},${sub_pipe_flag},${all_case_count},${succ_case_count},${fail_case_count}" > "${all_case_count_file}"

  358. 

  359. cat "${case_result_file}"

  360. echo "pipe_line_type:${pipe_line_type},sub_pipe_flag:${sub_pipe_flag},all_case_count:${all_case_count},succ_case_count:${succ_case_count},fail_case_count:${fail_case_count}, log_file_path:${log_file_path}"

  361. exit ${exit_flag}