derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
914 lines
40 KiB
CMake
Executable File
914 lines
40 KiB
CMake
Executable File
################################################################################
|
|
#
|
|
# MIT License
|
|
#
|
|
# Copyright (c) 2017 Advanced Micro Devices, Inc.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in all
|
|
# copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
#
|
|
################################################################################
|
|
|
|
cmake_policy(SET CMP0057 NEW)
|
|
|
|
include(CheckCXXCompilerFlag)
|
|
|
|
if(MIOPEN_USE_HIPBLASLT)
|
|
find_package(hipblaslt REQUIRED PATHS /opt/rocm $ENV{HIP_PATH})
|
|
endif()
|
|
|
|
if(MIOPEN_USE_ROCBLAS)
|
|
find_package(rocblas REQUIRED PATHS /opt/rocm $ENV{HIP_PATH})
|
|
endif()
|
|
|
|
option( MIOPEN_TEST_ALL "Run the full test suite" OFF )
|
|
option( MIOPEN_TEST_HALF "Test in half mode" OFF )
|
|
option( MIOPEN_TEST_INT8 "Test in int8 mode" OFF )
|
|
option( MIOPEN_TEST_BFLOAT16 "Test in bfloat16 mode" OFF )
|
|
option( MIOPEN_TEST_TF32 "Test in tf32 mode" OFF )
|
|
option( MIOPEN_TEST_GFX908 "Test on MI100 (gfx908)" OFF )
|
|
option( MIOPEN_TEST_GFX90A "Test on MI2X0 (gfx90a)" OFF )
|
|
option( MIOPEN_TEST_GFX94X "Test on MI300 (gfx942)" OFF )
|
|
option( MIOPEN_TEST_GFX95X "Test on (gfx950)" OFF )
|
|
option( MIOPEN_TEST_GFX900 "Test on Vega10 (gfx900)" OFF )
|
|
option( MIOPEN_TEST_GFX906 "Test on Vega20 (gfx906)" OFF )
|
|
option( MIOPEN_TEST_GFX103X "Test on Navi21/22 (gfx1030/31)" OFF )
|
|
option( MIOPEN_TEST_GFX110X "Test on Navi31/32/33/Phoenix (gfx1100/03)" OFF )
|
|
option( MIOPEN_TEST_GFX115X "Test on Navi35 strix halo (gfx1150/51/52/53)" OFF )
|
|
option( MIOPEN_TEST_GFX120X "Test on gfx1200/01" OFF )
|
|
option( MIOPEN_TEST_GFX125X "Test on gfx1250" OFF )
|
|
option( MIOPEN_TEST_GPU_XNACK_ENABLED "Test as if XNACK mode is enabled" OFF )
|
|
option( MIOPEN_TEST_CONV "" OFF )
|
|
option( MIOPEN_TEST_DEEPBENCH "" OFF )
|
|
option( MIOPEN_TEST_DRIVER_ITER_MODE "" OFF )
|
|
option( MIOPEN_TEST_COMPOSABLEKERNEL "Test with composable_kernel library" ${MIOPEN_USE_COMPOSABLEKERNEL} )
|
|
option( MIOPEN_TEST_DISCRETE "Build Discrete Test Binaries" ON )
|
|
option( MIOPEN_TEST_DBSYNC "" OFF )
|
|
option( MIOPEN_TEST_PERF "" OFF )
|
|
option( MIOPEN_TEST_ENABLE_TEST_SQLITE_PERFDB "Enable the SQLite Perf DB test" OFF)
|
|
|
|
if(NOT ENABLE_ASAN_PACKAGING AND MIOPEN_TEST_PERF)
|
|
set( CMAKE_INSTALL_TESTBINDIR "${DATA_INSTALL_DIR}/bin" )
|
|
set(test_perf.py ${CMAKE_INSTALL_TESTBINDIR}/test_perf.py)
|
|
install(FILES test_perf.py
|
|
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
|
|
DESTINATION ${CMAKE_INSTALL_TESTBINDIR})
|
|
|
|
set(MODEL_FILES)
|
|
file (GLOB model_src CONFIGURE_DEPENDS perf_models/*.txt)
|
|
foreach (src ${model_src})
|
|
list (APPEND MODEL_FILES ${src})
|
|
endforeach()
|
|
|
|
install(FILES
|
|
${MODEL_FILES}
|
|
DESTINATION ${DATA_INSTALL_DIR}/perf_models)
|
|
foreach(MODEL_FILE ${MODEL_FILES})
|
|
get_filename_component(MODEL_FILE_FILENAME "${MODEL_FILE}" NAME)
|
|
configure_file("${MODEL_FILE}" "${CMAKE_BINARY_DIR}/${DATA_INSTALL_DIR}/perf_models/${MODEL_FILE_FILENAME}" COPYONLY)
|
|
endforeach()
|
|
endif()
|
|
|
|
set_var_to_condition(MIOPEN_TEST_WITH_MIOPENDRIVER_DEFAULT MIOPEN_BUILD_DRIVER)
|
|
option( MIOPEN_TEST_WITH_MIOPENDRIVER "Use MIOpenDriver in tests" ${MIOPEN_TEST_WITH_MIOPENDRIVER_DEFAULT})
|
|
|
|
option( WORKAROUND_ISSUE_936 "" ON)
|
|
|
|
# Run the test suite to a depth limit
|
|
#limit greater than 2 leads to prolonged testing more than 5hrs per stage.
|
|
set(MIOPEN_TEST_LIMIT "2" CACHE STRING "")
|
|
set(MIOPEN_TEST_FLAGS "" CACHE STRING "")
|
|
set(MIOPEN_TEST_GDB On CACHE BOOL "")
|
|
|
|
set(MIOPEN_TEST_HIP_NOGPU FALSE)
|
|
if(MIOPEN_MODE_NOGPU)
|
|
set(MIOPEN_TEST_HIP_NOGPU TRUE)
|
|
endif()
|
|
|
|
set(MIOPEN_TEST_HIP FALSE)
|
|
if(MIOPEN_BACKEND_HIP AND NOT MIOPEN_TEST_HIP_NOGPU)
|
|
set(MIOPEN_TEST_HIP TRUE)
|
|
endif()
|
|
|
|
# Detect GPU type for testing.
|
|
# For HIP_NOGPU backend, GPU detection is not required and should be disabled.
|
|
# Also we do not detect GPU when target GPU for testing is specified explicitly.
|
|
set(MIOPEN_TEST_GPU_DETECTION_FAILED FALSE)
|
|
set(MIOPEN_NO_GPU FALSE)
|
|
|
|
if(NOT (MIOPEN_TEST_GFX900 OR MIOPEN_TEST_GFX906 OR MIOPEN_TEST_GFX908 OR MIOPEN_TEST_GFX90A OR MIOPEN_TEST_GFX94X OR MIOPEN_TEST_GFX95X OR MIOPEN_TEST_GFX103X OR MIOPEN_TEST_GFX110X OR MIOPEN_TEST_GFX115X OR MIOPEN_TEST_GFX120X OR MIOPEN_TEST_GFX125X OR MIOPEN_TEST_HIP_NOGPU))
|
|
# Try to find rocminfo first, then hipinfo as fallback (for Windows)
|
|
find_program(ROCMINFO
|
|
NAMES rocminfo hipinfo
|
|
PATHS
|
|
/opt/rocm
|
|
${CMAKE_INSTALL_PREFIX}
|
|
$ENV{ROCM_PATH}
|
|
$ENV{HIP_PATH}
|
|
PATH_SUFFIXES
|
|
/bin
|
|
)
|
|
message(STATUS "GPU info utility: ${ROCMINFO}")
|
|
if(ROCMINFO)
|
|
execute_process (
|
|
COMMAND ${ROCMINFO}
|
|
OUTPUT_VARIABLE ROCMINFO_OUTPUT
|
|
RESULT_VARIABLE ROCMINFO_EXIT_STATUS
|
|
)
|
|
if(ROCMINFO_OUTPUT MATCHES "no GPU devices")
|
|
message(WARNING "ROCk module is NOT loaded, possibly no GPU devices")
|
|
set(MIOPEN_NO_GPU TRUE)
|
|
elseif (NOT ROCMINFO_EXIT_STATUS EQUAL 0)
|
|
message(WARNING "GPU info utility FAILED, GPU TYPE UNKNOWN. Manually set respective MIOPEN_TEST_GFX* CMake variable to specify target GPU for testing.")
|
|
set(MIOPEN_TEST_GPU_DETECTION_FAILED TRUE)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx103.")
|
|
set(MIOPEN_TEST_GFX103X ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx110.")
|
|
set(MIOPEN_TEST_GFX110X ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx115.")
|
|
set(MIOPEN_TEST_GFX115X ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx120.")
|
|
set(MIOPEN_TEST_GFX120X ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx125.")
|
|
set(MIOPEN_TEST_GFX125X ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx900")
|
|
set(MIOPEN_TEST_GFX900 ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx906")
|
|
set(MIOPEN_TEST_GFX906 ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx908")
|
|
set(MIOPEN_TEST_GFX908 ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx90a")
|
|
set(MIOPEN_TEST_GFX90A ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx942")
|
|
set(MIOPEN_TEST_GFX94X ON)
|
|
elseif(ROCMINFO_OUTPUT MATCHES "gfx95")
|
|
set(MIOPEN_TEST_GFX95X ON)
|
|
else()
|
|
message(WARNING "TESTING IS NOT SUPPORTED FOR THE DETECTED GPU")
|
|
set(MIOPEN_TEST_GPU_DETECTION_FAILED TRUE)
|
|
endif()
|
|
|
|
if(NOT (MIOPEN_TEST_GPU_DETECTION_FAILED) AND ROCMINFO_OUTPUT MATCHES "xnack\\+")
|
|
set(MIOPEN_TEST_GPU_XNACK_ENABLED ON)
|
|
endif()
|
|
|
|
if(MIOPEN_TEST_GPU_DETECTION_FAILED)
|
|
message(STATUS "${ROCMINFO_OUTPUT}")
|
|
endif()
|
|
else()
|
|
message(WARNING "GPU info utility FAILED, GPU TYPE UNKNOWN. Manually set respective MIOPEN_TEST_GFX* CMake variable to specify target GPU for testing.")
|
|
set(MIOPEN_TEST_GPU_DETECTION_FAILED TRUE)
|
|
endif()
|
|
endif()
|
|
|
|
set(MIOPEN_LIBMLIR_SUPPORTS_GFX103X_DEFAULT FALSE)
|
|
if(MIOPEN_USE_MLIR)
|
|
set_var_to_condition(MIOPEN_LIBMLIR_SUPPORTS_GFX103X_DEFAULT (${rocMLIR_VERSION} VERSION_GREATER_EQUAL 1))
|
|
endif()
|
|
option( MIOPEN_LIBMLIR_SUPPORTS_GFX103X "libMLIR capability to support GFX10. Enables MLIR tests on GFX103X." ${MIOPEN_LIBMLIR_SUPPORTS_GFX103X_DEFAULT})
|
|
|
|
set_var_to_condition(MIOPEN_TEST_MLIR_DEFAULT ${MIOPEN_USE_MLIR} AND NOT (${MIOPEN_TEST_GFX103X} AND NOT ${MIOPEN_LIBMLIR_SUPPORTS_GFX103X}))
|
|
option( MIOPEN_TEST_MLIR "Test for MLIR compilation backend" ${MIOPEN_TEST_MLIR_DEFAULT} )
|
|
|
|
if((NOT MIOPEN_ENABLE_SQLITE) OR (NOT MIOPEN_EMBED_DB STREQUAL ""))
|
|
set(MIOPEN_TEST_ENABLE_TEST_SQLITE_PERFDB OFF)
|
|
endif()
|
|
|
|
message(STATUS "MIOPEN_NO_GPU ${MIOPEN_NO_GPU}")
|
|
message(STATUS "MIOPEN_TEST_GFX900 ${MIOPEN_TEST_GFX900}")
|
|
message(STATUS "MIOPEN_TEST_GFX906 ${MIOPEN_TEST_GFX906}")
|
|
message(STATUS "MIOPEN_TEST_GFX908 ${MIOPEN_TEST_GFX908}")
|
|
message(STATUS "MIOPEN_TEST_GFX90A ${MIOPEN_TEST_GFX90A}")
|
|
message(STATUS "MIOPEN_TEST_GFX94X ${MIOPEN_TEST_GFX94X}")
|
|
message(STATUS "MIOPEN_TEST_GFX95X ${MIOPEN_TEST_GFX95X}")
|
|
message(STATUS "MIOPEN_TEST_GFX103X ${MIOPEN_TEST_GFX103X}")
|
|
message(STATUS "MIOPEN_TEST_GFX110X ${MIOPEN_TEST_GFX110X}")
|
|
message(STATUS "MIOPEN_TEST_GFX115X ${MIOPEN_TEST_GFX115X}")
|
|
message(STATUS "MIOPEN_TEST_GFX120X ${MIOPEN_TEST_GFX120X}")
|
|
message(STATUS "MIOPEN_TEST_GFX125X ${MIOPEN_TEST_GFX125X}")
|
|
message(STATUS "MIOPEN_TEST_GPU_XNACK_ENABLED ${MIOPEN_TEST_GPU_XNACK_ENABLED}")
|
|
message(STATUS "MIOPEN_TEST_GPU_DETECTION_FAILED ${MIOPEN_TEST_GPU_DETECTION_FAILED}")
|
|
message(STATUS "MIOPEN_TEST_WITH_MIOPENDRIVER ${MIOPEN_TEST_WITH_MIOPENDRIVER}")
|
|
message(STATUS "MIOPEN_TEST_MLIR ${MIOPEN_TEST_MLIR}")
|
|
message(STATUS "MIOPEN_TEST_CONV ${MIOPEN_TEST_CONV}")
|
|
message(STATUS "MIOPEN_TEST_DEEPBENCH ${MIOPEN_TEST_DEEPBENCH}")
|
|
message(STATUS "MIOPEN_TEST_DRIVER_ITER_MODE ${MIOPEN_TEST_DRIVER_ITER_MODE}")
|
|
message(STATUS "MIOPEN_TEST_COMPOSABLEKERNEL ${MIOPEN_TEST_COMPOSABLEKERNEL}")
|
|
message(STATUS "MIOPEN_TEST_DISCRETE ${MIOPEN_TEST_DISCRETE}")
|
|
message(STATUS "MIOPEN_TEST_DBSYNC ${MIOPEN_TEST_DBSYNC}")
|
|
message(STATUS "MIOPEN_TEST_PERF ${MIOPEN_TEST_PERF}")
|
|
message(STATUS "MIOPEN_TEST_ENABLE_TEST_SQLITE_PERFDB ${MIOPEN_TEST_ENABLE_TEST_SQLITE_PERFDB}")
|
|
|
|
if(MIOPEN_TEST_DRIVER_ITER_MODE)
|
|
add_definitions(-DMIOPEN_TEST_DRIVER_MODE=2)
|
|
else()
|
|
add_definitions(-DMIOPEN_TEST_DRIVER_MODE=1)
|
|
endif()
|
|
|
|
# Project-prefixed targets avoid collisions when included via add_subdirectory in a superbuild.
|
|
# Unprefixed `check` / `tests` / `gpu_detection_check` aliases are created standalone-only.
|
|
add_custom_target(miopen-check
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/test_results
|
|
COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --verbose -C ${CMAKE_CFG_INTDIR} --exclude-regex ".*_suite" COMMENT "Running MIOpen tests"
|
|
)
|
|
add_custom_target(miopen-tests COMMENT "Aggregate target for MIOpen tests")
|
|
|
|
if(MIOPEN_TEST_GPU_DETECTION_FAILED AND NOT (MIOPEN_NO_GPU))
|
|
add_custom_target(miopen-gpu-detection-check COMMAND echo "*** FATAL: GPU DETECTION FAILED DURING CMAKE PHASE, CHECK CMAKE WARNINGS ***" COMMAND exit 1 COMMENT "Reporting failed GPU detection")
|
|
add_dependencies(miopen-check miopen-gpu-detection-check)
|
|
if(NOT ROCM_LIBS_SUPERBUILD)
|
|
add_custom_target(gpu_detection_check DEPENDS miopen-gpu-detection-check COMMENT "Back-compat alias for miopen-gpu-detection-check")
|
|
endif()
|
|
endif()
|
|
|
|
if(MIOPEN_TEST_WITH_MIOPENDRIVER)
|
|
add_dependencies(miopen-check MIOpenDriver)
|
|
endif()
|
|
|
|
set(MIOPEN_GTEST_SUFFIX)
|
|
set(MIOPEN_TEST_FLOAT_ARG)
|
|
set(MIOPEN_TEST_FLOAT FALSE)
|
|
set(MIOPEN_TEST_CONV_INT8_OUTPUT_TYPE_INT8)
|
|
set(MIOPEN_TEST_CONV_INT8_OUTPUT_TYPE_INT32)
|
|
set(MIOPEN_TEST_CONV_INT8_OUTPUT_TYPE_FLOAT)
|
|
if(MIOPEN_TEST_HALF)
|
|
set(MIOPEN_GTEST_SUFFIX FP16)
|
|
set(MIOPEN_TEST_FLOAT_ARG --half)
|
|
set(MIOPENDRIVER_MODE_CONV convfp16)
|
|
set(MIOPENDRIVER_MODE_BN bnormfp16)
|
|
set(MIOPENDRIVER_MODE_POOL poolfp16)
|
|
set(MIOPENDRIVER_MODE_GEMM gemmfp16)
|
|
elseif(MIOPEN_TEST_INT8)
|
|
set(MIOPEN_GTEST_SUFFIX I8)
|
|
set(MIOPEN_TEST_FLOAT_ARG --int8)
|
|
set(MIOPENDRIVER_MODE_CONV convint8)
|
|
set(MIOPENDRIVER_MODE_BN NOT_SUPPORTED)
|
|
set(MIOPENDRIVER_MODE_POOL NOT_SUPPORTED)
|
|
set(MIOPENDRIVER_MODE_GEMM NOT_SUPPORTED)
|
|
set(MIOPEN_TEST_CONV_INT8_OUTPUT_TYPE_INT8 --output_type int8)
|
|
set(MIOPEN_TEST_CONV_INT8_OUTPUT_TYPE_INT32 --output_type int32)
|
|
set(MIOPEN_TEST_CONV_INT8_OUTPUT_TYPE_FLOAT --output_type float)
|
|
elseif(MIOPEN_TEST_BFLOAT16)
|
|
set(MIOPEN_GTEST_SUFFIX BFP16)
|
|
set(MIOPEN_TEST_FLOAT_ARG --bfloat16)
|
|
set(MIOPENDRIVER_MODE_CONV convbfp16)
|
|
set(MIOPENDRIVER_MODE_BN NOT_SUPPORTED)
|
|
set(MIOPENDRIVER_MODE_POOL NOT_SUPPORTED)
|
|
set(MIOPENDRIVER_MODE_GEMM NOT_SUPPORTED)
|
|
elseif(MIOPEN_TEST_TF32)
|
|
set(MIOPEN_GTEST_SUFFIX TF32)
|
|
set(MIOPEN_TEST_FLOAT_ARG --float) # TODO: not integrated in test_conv2d
|
|
set(MIOPENDRIVER_MODE_CONV conv)
|
|
set(MIOPENDRIVER_MODE_BN NOT_SUPPORTED)
|
|
set(MIOPENDRIVER_MODE_POOL NOT_SUPPORTED)
|
|
set(MIOPENDRIVER_MODE_GEMM NOT_SUPPORTED)
|
|
else()
|
|
set(MIOPEN_GTEST_SUFFIX FP32)
|
|
set(MIOPEN_TEST_FLOAT_ARG --float)
|
|
set(MIOPEN_TEST_FLOAT TRUE)
|
|
set(MIOPENDRIVER_MODE_CONV conv)
|
|
set(MIOPENDRIVER_MODE_BN bnorm)
|
|
set(MIOPENDRIVER_MODE_POOL pool)
|
|
set(MIOPENDRIVER_MODE_GEMM gemm)
|
|
endif()
|
|
|
|
message(STATUS "MIOPEN_GTEST_SUFFIX ${MIOPEN_GTEST_SUFFIX}")
|
|
message(STATUS "MIOPEN_TEST_FLOAT ${MIOPEN_TEST_FLOAT}")
|
|
message(STATUS "MIOPEN_TEST_HALF ${MIOPEN_TEST_HALF}")
|
|
message(STATUS "MIOPEN_TEST_BFLOAT16 ${MIOPEN_TEST_BFLOAT16}")
|
|
message(STATUS "MIOPEN_TEST_TF32 ${MIOPEN_TEST_TF32}")
|
|
message(STATUS "MIOPEN_TEST_INT8 ${MIOPEN_TEST_INT8}")
|
|
message(STATUS "MIOPEN_TEST_ALL ${MIOPEN_TEST_ALL}")
|
|
|
|
set_var_to_condition(WORKAROUND_ISSUE_1187_DEFAULT MIOPEN_TEST_GFX90A AND MIOPEN_TEST_FLOAT)
|
|
option( WORKAROUND_ISSUE_1187 "" ${WORKAROUND_ISSUE_1187_DEFAULT})
|
|
|
|
set_var_to_condition(WORKAROUND_ISSUE_1148_DEFAULT (MIOPEN_TEST_GFX103X OR MIOPEN_TEST_GFX110X OR MIOPEN_TEST_GFX115X) AND MIOPEN_TEST_FLOAT)
|
|
option( WORKAROUND_ISSUE_1148 "" ${WORKAROUND_ISSUE_1148_DEFAULT})
|
|
|
|
if(MIOPEN_TEST_INT8)
|
|
set(SKIP_ALL_EXCEPT_TESTS
|
|
test_tensor_vec test_tensor_trans test_tensor_transform test_conv2d test_conv2d_find2)
|
|
elseif(MIOPEN_TEST_BFLOAT16)
|
|
set(SKIP_ALL_EXCEPT_TESTS
|
|
test_conv2d test_conv2d_find2 test_tensor_vec test_immed_conv2d
|
|
test_conv_extra test_conv_for_implicit_gemm test_miopen_conv
|
|
test_deepbench_conv test_conv_igemm_dynamic_xdlops_nhwc_wrw_bf16
|
|
test_conv_igemm_dynamic_xdlops_nhwc_fwd_bf16
|
|
test_conv_igemm_dynamic_xdlops_nhwc_bwd_bf16)
|
|
endif()
|
|
|
|
if(MIOPEN_NO_GPU)
|
|
set(SKIP_ALL_EXCEPT_TESTS
|
|
test_sqlite_perfdb)
|
|
endif()
|
|
|
|
#TODO WORKAROUND_ISSUE_1424
|
|
if(MIOPEN_TEST_GFX900 OR MIOPEN_TEST_GFX906 OR MIOPEN_TEST_GFX908)
|
|
list(APPEND SKIP_TESTS test_bn_3d_spatial_test)
|
|
endif()
|
|
|
|
#Don't run db verification by default
|
|
if(NOT MIOPEN_TEST_DBSYNC)
|
|
list(APPEND SKIP_TESTS db_sync)
|
|
endif()
|
|
|
|
if (MIOPEN_TEST_GFX115X)
|
|
list(APPEND SKIP_TESTS test_ctc)
|
|
endif()
|
|
|
|
# Skip conv2d tests to capture flaky behavior
|
|
list(APPEND SKIP_TESTS test_conv2d test_conv2d_find2)
|
|
|
|
# Skip test_immed_conv2d tests to capture flaky behavior
|
|
list(APPEND SKIP_TESTS test_immed_conv2d)
|
|
|
|
|
|
# The usage is non-trivial, see function add_test_command.
|
|
if(SKIP_TESTS)
|
|
list(REMOVE_DUPLICATES SKIP_TESTS)
|
|
endif()
|
|
if(SKIP_ALL_EXCEPT_TESTS)
|
|
list(REMOVE_DUPLICATES SKIP_ALL_EXCEPT_TESTS)
|
|
endif()
|
|
message(STATUS "SKIP_TESTS: ${SKIP_TESTS}")
|
|
message(STATUS "SKIP_ALL_EXCEPT_TESTS: ${SKIP_ALL_EXCEPT_TESTS}")
|
|
|
|
# List of tests that depend on the XNACK mode.
|
|
# Options convention: Tests that depend on the XNACK mode should support the "--xnack" option.
|
|
# If "--xnack 0" is specified (this is the default), then such tests should run in XNACK OFF mode.
|
|
# If XNACK is enabled on the GPU, then the testing mode must be changed by the --xnack 1 option.
|
|
set(XNACK_TESTS test_mdgraph)
|
|
|
|
# Register a ctest entry for NAME, honoring skip lists and GDB/Windows modes.
|
|
function(add_test_command NAME EXE)
|
|
if( (NOT (NAME IN_LIST SKIP_ALL_EXCEPT_TESTS) AND SKIP_ALL_EXCEPT_TESTS)
|
|
OR (NAME IN_LIST SKIP_TESTS)
|
|
)
|
|
add_test(NAME ${NAME} COMMAND echo skipped)
|
|
set_tests_properties(${NAME} PROPERTIES DISABLED On)
|
|
elseif(WIN32)
|
|
add_test(NAME ${NAME} COMMAND $<TARGET_FILE:${EXE}> ${ARGN} WORKING_DIRECTORY "${KERNELS_BINARY_DIR}")
|
|
else()
|
|
if(MIOPEN_TEST_GDB)
|
|
file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/test_${NAME}.cmake"
|
|
CONTENT "
|
|
execute_process(COMMAND $<TARGET_FILE:${EXE}> ${ARGN} RESULT_VARIABLE RESULT)
|
|
if(NOT RESULT EQUAL 0)
|
|
if(EXISTS core)
|
|
execute_process(COMMAND gdb $<TARGET_FILE:${EXE}> core -batch -ex bt)
|
|
endif()
|
|
message(FATAL_ERROR \"Test failed\")
|
|
endif()
|
|
")
|
|
add_test(NAME ${NAME} COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/test_${NAME}.cmake")
|
|
else()
|
|
add_test(NAME ${NAME} COMMAND ${EXE} ${ARGN})
|
|
endif()
|
|
endif()
|
|
set_tests_properties(${NAME} PROPERTIES ENVIRONMENT "MIOPEN_USER_DB_PATH=${CMAKE_CURRENT_BINARY_DIR}")
|
|
endfunction()
|
|
|
|
separate_arguments(MIOPEN_TEST_FLAGS_ARGS NATIVE_COMMAND ${MIOPEN_TEST_FLAGS})
|
|
|
|
# Build a test executable, wire up its libraries, and register it with ctest.
|
|
function(add_test_executable TEST_NAME)
|
|
# cmake-lint: disable=R0912
|
|
add_executable (${TEST_NAME} EXCLUDE_FROM_ALL ${ARGN})
|
|
if(WIN32)
|
|
target_compile_definitions(${TEST_NAME} PRIVATE NOMINMAX)
|
|
endif()
|
|
clang_tidy_check(${TEST_NAME})
|
|
target_link_libraries(${TEST_NAME} Threads::Threads)
|
|
# Cmake does not add flags correctly for gcc
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
|
|
set_target_properties(${TEST_NAME} PROPERTIES COMPILE_FLAGS -pthread LINK_FLAGS -pthread)
|
|
endif()
|
|
|
|
set(TEST_COMMAND ${TEST_NAME} ${MIOPEN_TEST_FLOAT_ARG})
|
|
if(MIOPEN_TEST_ALL)
|
|
set(TEST_COMMAND ${TEST_COMMAND} --all)
|
|
if(MIOPEN_TEST_LIMIT GREATER 0)
|
|
set(TEST_COMMAND ${TEST_COMMAND} --limit ${MIOPEN_TEST_LIMIT})
|
|
endif()
|
|
endif()
|
|
set(TEST_COMMAND ${TEST_COMMAND} ${MIOPEN_TEST_FLAGS_ARGS})
|
|
|
|
if(MIOPEN_TEST_GPU_XNACK_ENABLED AND (${TEST_NAME} IN_LIST XNACK_TESTS))
|
|
set(TEST_COMMAND ${TEST_COMMAND} --xnack 1)
|
|
endif()
|
|
|
|
if(WORKAROUND_ISSUE_936 AND (${TEST_NAME} MATCHES "test_conv2d" OR ${TEST_NAME} MATCHES "test_immed_conv2d") )
|
|
set(TEST_COMMAND ${TEST_COMMAND} --tolerance 130) #increased by 1.625 times
|
|
endif()
|
|
|
|
add_test_command(${TEST_NAME} ${TEST_COMMAND})
|
|
rate_added_test(${TEST_NAME})
|
|
add_dependencies(miopen-tests ${TEST_NAME})
|
|
add_dependencies(miopen-check ${TEST_NAME})
|
|
set_tests_properties(${TEST_NAME} PROPERTIES FAIL_REGULAR_EXPRESSION "FAILED")
|
|
if(WORKAROUND_ISSUE_1148
|
|
AND (${TEST_NAME} MATCHES "test_soft_max") )
|
|
set_tests_properties(${TEST_NAME} PROPERTIES RUN_SERIAL On)
|
|
endif()
|
|
# MIOpen_with_plugins ensures CK plugin .so's are built alongside the test
|
|
if(NOT MIOPEN_EMBED_DB STREQUAL "")
|
|
target_link_libraries(${TEST_NAME} MIOpen_with_plugins miopen_data)
|
|
else()
|
|
target_link_libraries(${TEST_NAME} MIOpen_with_plugins)
|
|
endif()
|
|
target_include_directories(${TEST_NAME} PRIVATE ../src/kernels)
|
|
if(WIN32)
|
|
# Refer to https://en.cppreference.com/w/cpp/language/types for details.
|
|
target_compile_options(${TEST_NAME} PRIVATE $<BUILD_INTERFACE:$<$<CXX_COMPILER_ID:Clang>:-U__LP64__>>)
|
|
endif()
|
|
if(HAS_LIB_STD_FILESYSTEM)
|
|
target_link_libraries(${TEST_NAME} stdc++fs)
|
|
endif()
|
|
# Need to add hipblaslt since static builds of MIOpen require hipBLASLt linkage
|
|
if(hipblaslt_FOUND)
|
|
target_link_libraries( ${TEST_NAME} roc::hipblaslt )
|
|
endif()
|
|
# Need to add rocBLAS since static builds of MIOpen require rocBLAS linkage
|
|
if(rocblas_FOUND)
|
|
target_link_libraries( ${TEST_NAME} $<BUILD_INTERFACE:roc::rocblas> )
|
|
endif()
|
|
endfunction()
|
|
|
|
set(MIOPEN_TEST_SANITIZERS)
|
|
foreach(SANTIZER address thread)
|
|
check_cxx_compiler_flag("-fsanitize=${SANTIZER} -fno-sanitize-recover=${SANTIZER}" MIOPEN_HAS_${SANTIZER})
|
|
if(MIOPEN_HAS_${SANTIZER})
|
|
list(APPEND MIOPEN_TEST_SANITIZERS ${SANTIZER})
|
|
endif()
|
|
endforeach()
|
|
|
|
# Build sanitizer-instrumented variants of a test for each enabled sanitizer.
|
|
function(add_sanitize_test TEST_SOURCE)
|
|
get_filename_component(BASE_NAME ${TEST_SOURCE} NAME_WE)
|
|
foreach(SANTIZER ${MIOPEN_TEST_SANITIZERS})
|
|
add_test_executable(test_${BASE_NAME}_${SANTIZER} ${TEST_SOURCE})
|
|
target_compile_options(test_${BASE_NAME}_${SANTIZER} PUBLIC -fsanitize=${SANTIZER} -fno-sanitize-recover=${SANTIZER})
|
|
target_link_libraries(test_${BASE_NAME}_${SANTIZER} -fsanitize=${SANTIZER} -fno-sanitize-recover=${SANTIZER})
|
|
endforeach()
|
|
endfunction()
|
|
|
|
file(GLOB TEST_SOURCES *.cpp)
|
|
|
|
set(LONG_TESTS
|
|
test_conv2d
|
|
test_conv2d_find2
|
|
test_conv3d
|
|
test_conv3d_find2
|
|
test_conv_group
|
|
test_soft_max
|
|
test_conv_for_implicit_gemm
|
|
test_immed_conv3d
|
|
test_conv3d_extra
|
|
test_conv_3d
|
|
test_conv_ck_igemm_fwd_v6r1_dlops_nchw
|
|
)
|
|
|
|
# Assign a ctest COST to a test so long-running tests are scheduled first.
|
|
function(rate_added_test NAME)
|
|
if(${NAME} IN_LIST LONG_TESTS)
|
|
set_tests_properties(${NAME} PROPERTIES COST 800)
|
|
else()
|
|
set_tests_properties(${NAME} PROPERTIES COST 600)
|
|
endif()
|
|
endfunction()
|
|
|
|
set(EXCLUDE_TESTS)
|
|
if(NOT MIOPEN_ENABLE_SQLITE)
|
|
list(APPEND EXCLUDE_TESTS test_sqlite)
|
|
endif()
|
|
|
|
if(NOT MIOPEN_TEST_ENABLE_TEST_SQLITE_PERFDB)
|
|
list(APPEND EXCLUDE_TESTS test_sqlite_perfdb)
|
|
message(STATUS "Flaky test_sqlite_perfdb currently disabled (May 28 2025)")
|
|
endif()
|
|
|
|
set(EXCLUDE_TEST_SOURCES)
|
|
foreach(TEST_SOURCE ${TEST_SOURCES})
|
|
get_filename_component(BASE_NAME ${TEST_SOURCE} NAME_WE)
|
|
if(test_${BASE_NAME} IN_LIST EXCLUDE_TESTS)
|
|
list(APPEND EXCLUDE_TEST_SOURCES ${TEST_SOURCE})
|
|
endif()
|
|
endforeach()
|
|
unset(EXCLUDE_TESTS)
|
|
|
|
foreach(TEST_SOURCE ${EXCLUDE_TEST_SOURCES})
|
|
list(REMOVE_ITEM TEST_SOURCES ${TEST_SOURCE})
|
|
endforeach()
|
|
unset(EXCLUDE_TEST_SOURCES)
|
|
|
|
foreach(TEST_SOURCE ${TEST_SOURCES})
|
|
get_filename_component(BASE_NAME ${TEST_SOURCE} NAME_WE)
|
|
add_test_executable(test_${BASE_NAME} ${TEST_SOURCE})
|
|
endforeach()
|
|
|
|
if(MIOPEN_TEST_ENABLE_TEST_SQLITE_PERFDB)
|
|
set_tests_properties(test_sqlite_perfdb PROPERTIES RUN_SERIAL On)
|
|
endif()
|
|
|
|
# add_sanitize_test(perfdb.cpp)
|
|
# add_sanitize_test(cache.cpp)
|
|
# add_sanitize_test(tensor_test.cpp)
|
|
# add_sanitize_test(type_name.cpp)
|
|
|
|
# Set result to TRUE when the two boolean arguments are equal (XNOR).
|
|
function(bool_equality_f first_arg sec_arg result)
|
|
if(${first_arg})
|
|
if(${sec_arg})
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
else()
|
|
set(${result} FALSE PARENT_SCOPE)
|
|
endif()
|
|
elseif(${sec_arg})
|
|
set(${result} FALSE PARENT_SCOPE)
|
|
else()
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# Set result to the logical AND of the two boolean arguments.
|
|
function(bool_and_f first_arg sec_arg result)
|
|
if(${first_arg} AND ${sec_arg})
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
else()
|
|
set(${result} FALSE PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# Set result to the logical OR of the two boolean arguments.
|
|
function(bool_or_f first_arg sec_arg result)
|
|
if(${first_arg} OR ${sec_arg})
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
else()
|
|
set(${result} FALSE PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# Set result to the logical NOT of the boolean argument.
|
|
function(bool_not_f first_arg result)
|
|
if(${first_arg})
|
|
set(${result} FALSE PARENT_SCOPE)
|
|
else()
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# Resolve an enabled/disabled/default tri-state option into a boolean result.
|
|
function(option_support_check is_enabled is_disabled default_result result)
|
|
if(${is_enabled} AND ${is_disabled})
|
|
message(FATAL_ERROR " Incompatible options used")
|
|
endif()
|
|
if(${is_enabled})
|
|
set(${result} TRUE PARENT_SCOPE)
|
|
elseif(${is_disabled})
|
|
set(${result} FALSE PARENT_SCOPE)
|
|
else()
|
|
set(${result} ${default_result} PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
# The add_custom_test function contains attributes to describe the conditions,
|
|
# under which new custom_tests should be run. Attributes are divided into several types.
|
|
# The attribute can be enabled or disabled; if nothing is specified, the default value is taken.
|
|
# You can use any number of attributes, in any order, provided that attributes do not conflict
|
|
# (e.g. "HALF_ENABLED HALF_DISABLED" is illegal)
|
|
#
|
|
# Data types: FLOAT HALF BF16 INT8
|
|
# These attributes can be enabled or disabled by using '_ENABLED' and '_DISABLED' suffix.
|
|
# Defaults: FLOAT_ENABLED HALF_DISABLED BF16_DISABLED INT8_DISABLED
|
|
#
|
|
# GPU types: GFX900, GFX906, GFX908, GFX90A, GFX94X, GFX1030/31, GFX1100/02, GFX115X
|
|
# These attributes can be enabled or disabled by using '_ENABLED' and '_DISABLED' suffix.
|
|
# Defaults: GFX900_ENABLED, GFX906_ENABLED, GFX908_ENABLED, GFX90A_ENABLED, GFX94X_DISABLED, GFX103X_DISABLED, GFX110X_DISABLED, GFX115X_DISABLED
|
|
#
|
|
# Testing mode:
|
|
# SKIP_UNLESS_ALL - The test should be only run if MIOPEN_TEST_ALL=TRUE. Intended for long tests.
|
|
# TEST_PERF_DB_RECORD_NOT_FOUND - Test should fail if output contains: "Perf Db: record not found".
|
|
# TEST_TUNING - In addition to the standard checks, the test should fail if output contains "Error" or "failed".
|
|
# SKIP_XNACK_ON - Do not run the test if XNACK mode is enabled (xnack+) on the GPU.
|
|
# SKIP_UNLESS_MLIR - The test should be only run if MIOPEN_TEST_MLIR=TRUE.
|
|
# SKIP_UNLESS_COMPOSABLEKERNEL - The test should be only run if MIOPEN_TEST_COMPOSABLEKERNEL=TRUE.
|
|
#
|
|
# Backend: HIP HIP_NOGPU
|
|
# These attributes can be enabled or disabled by using '_ENABLED' and '_DISABLED' suffix.
|
|
# Default: HIP_ENABLED HIP_NOGPU_DISABLED.
|
|
function(add_custom_test NAME)
|
|
# cmake-lint: disable=R0915
|
|
set(options
|
|
BF16_ENABLED BF16_DISABLED HALF_ENABLED HALF_DISABLED INT8_ENABLED INT8_DISABLED TF32_ENABLED TF32_DISABLED FLOAT_ENABLED FLOAT_DISABLED
|
|
GFX900_ENABLED GFX900_DISABLED GFX906_ENABLED GFX906_DISABLED GFX908_ENABLED GFX908_DISABLED
|
|
GFX103X_ENABLED GFX103X_DISABLED GFX110X_ENABLED GFX110X_DISABLED GFX115X_ENABLED GFX115X_DISABLED GFX90A_ENABLED GFX90A_DISABLED GFX94X_ENABLED GFX94X_DISABLED
|
|
SKIP_UNLESS_MLIR SKIP_UNLESS_COMPOSABLEKERNEL SKIP_UNLESS_ALL TEST_PERF_DB_RECORD_NOT_FOUND TEST_TUNING SKIP_XNACK_ON
|
|
HIP_ENABLED HIP_DISABLED HIP_NOGPU_ENABLED HIP_NOGPU_DISABLED
|
|
)
|
|
set(oneValueArgs)
|
|
set(multiValueArgs ENVIRONMENT)
|
|
cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
|
|
# Many custom tests do test only FP32 data type and therefore
|
|
# added only if none of MIOPEN_TEST_HALF, MIOPEN_TEST_INT8, MIOPEN_TEST_TF32, MIOPEN_TEST_BFLOAT16
|
|
# are set, except the test is allowed explicitly.
|
|
set(HALF_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_HALF_ENABLED} ${PARSE_HALF_DISABLED} ${HALF_TEST_DEFAULT} is_half_check)
|
|
bool_and_f(${MIOPEN_TEST_HALF} ${is_half_check} is_half_check)
|
|
|
|
set(BF16_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_BF16_ENABLED} ${PARSE_BF16_DISABLED} ${BF16_TEST_DEFAULT} is_bfloat16_check)
|
|
bool_and_f(${MIOPEN_TEST_BFLOAT16} ${is_bfloat16_check} is_bfloat16_check)
|
|
|
|
set(INT8_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_INT8_ENABLED} ${PARSE_INT8_DISABLED} ${INT8_TEST_DEFAULT} is_int8_check)
|
|
bool_and_f(${MIOPEN_TEST_INT8} ${is_int8_check} is_int8_check)
|
|
|
|
set(TF32_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_TF32_ENABLED} ${PARSE_TF32_DISABLED} ${TF32_TEST_DEFAULT} is_tf32_check)
|
|
bool_and_f(${MIOPEN_TEST_TF32} ${is_tf32_check} is_tf32_check)
|
|
|
|
set(FLOAT_TEST_DEFAULT TRUE)
|
|
option_support_check(${PARSE_FLOAT_ENABLED} ${PARSE_FLOAT_DISABLED} ${FLOAT_TEST_DEFAULT} is_float_check)
|
|
bool_and_f(${MIOPEN_TEST_FLOAT} ${is_float_check} is_float_check)
|
|
|
|
bool_not_f(${PARSE_SKIP_UNLESS_MLIR} is_mlir_check)
|
|
bool_or_f(${is_mlir_check} ${MIOPEN_TEST_MLIR} is_mlir_check)
|
|
|
|
bool_not_f(${PARSE_SKIP_UNLESS_COMPOSABLEKERNEL} is_composablekernel_check)
|
|
bool_or_f(${is_composablekernel_check} ${MIOPEN_TEST_COMPOSABLEKERNEL} is_composablekernel_check)
|
|
|
|
set(HIP_TEST_DEFAULT TRUE)
|
|
option_support_check(${PARSE_HIP_ENABLED} ${PARSE_HIP_DISABLED} ${HIP_TEST_DEFAULT} is_hip_check)
|
|
bool_not_f(${MIOPEN_TEST_HIP} NOT_MIOPEN_TEST_HIP)
|
|
bool_or_f(${NOT_MIOPEN_TEST_HIP} ${is_hip_check} is_hip_check)
|
|
|
|
set(HIP_NOGPU_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_HIP_NOGPU_ENABLED} ${PARSE_HIP_NOGPU_DISABLED} ${HIP_NOGPU_TEST_DEFAULT} is_hip_nogpu_check)
|
|
bool_not_f(${MIOPEN_TEST_HIP_NOGPU} NOT_MIOPEN_TEST_HIP_NOGPU)
|
|
bool_or_f(${NOT_MIOPEN_TEST_HIP_NOGPU} ${is_hip_nogpu_check} is_hip_nogpu_check)
|
|
|
|
# Some tests are xDLOPs specific and should not run on gfx900/906 targets.
|
|
set(GFX900_TEST_DEFAULT TRUE)
|
|
option_support_check(${PARSE_GFX900_ENABLED} ${PARSE_GFX900_DISABLED} ${GFX900_TEST_DEFAULT} is_gfx900_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX900} ${is_gfx900_check} is_gfx900_check)
|
|
|
|
set(GFX906_TEST_DEFAULT TRUE)
|
|
option_support_check(${PARSE_GFX906_ENABLED} ${PARSE_GFX906_DISABLED} ${GFX906_TEST_DEFAULT} is_gfx906_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX906} ${is_gfx906_check} is_gfx906_check)
|
|
|
|
set(GFX908_TEST_DEFAULT TRUE)
|
|
option_support_check(${PARSE_GFX908_ENABLED} ${PARSE_GFX908_DISABLED} ${GFX908_TEST_DEFAULT} is_gfx908_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX908} ${is_gfx908_check} is_gfx908_check)
|
|
|
|
set(GFX90A_TEST_DEFAULT TRUE)
|
|
option_support_check(${PARSE_GFX90A_ENABLED} ${PARSE_GFX90A_DISABLED} ${GFX90A_TEST_DEFAULT} is_gfx90a_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX90A} ${is_gfx90a_check} is_gfx90a_check)
|
|
|
|
set(GFX94X_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_GFX94X_ENABLED} ${PARSE_GFX94X_DISABLED} ${GFX94X_TEST_DEFAULT} is_gfx94x_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX94X} ${is_gfx94x_check} is_gfx94x_check)
|
|
|
|
set(GFX103X_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_GFX103X_ENABLED} ${PARSE_GFX103X_DISABLED} ${GFX103X_TEST_DEFAULT} is_gfx103x_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX103X} ${is_gfx103x_check} is_gfx103x_check)
|
|
|
|
set(GFX110X_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_GFX110X_ENABLED} ${PARSE_GFX110X_DISABLED} ${GFX110X_TEST_DEFAULT} is_gfx110x_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX110X} ${is_gfx110x_check} is_gfx110x_check)
|
|
|
|
set(GFX115X_TEST_DEFAULT FALSE)
|
|
option_support_check(${PARSE_GFX115X_ENABLED} ${PARSE_GFX115X_DISABLED} ${GFX115X_TEST_DEFAULT} is_gfx115x_check)
|
|
bool_and_f(${MIOPEN_TEST_GFX115X} ${is_gfx115x_check} is_gfx115x_check)
|
|
|
|
# When SKIP_XNACK_ON is set, the test will be skipped if MIOPEN_TEST_GPU_XNACK_ENABLED is set.
|
|
bool_and_f(${PARSE_SKIP_XNACK_ON} ${MIOPEN_TEST_GPU_XNACK_ENABLED} is_xnack_on_check)
|
|
bool_not_f(${is_xnack_on_check} is_xnack_on_check)
|
|
|
|
bool_not_f(${PARSE_SKIP_UNLESS_ALL} is_full_check)
|
|
bool_or_f(${is_full_check} ${MIOPEN_TEST_ALL} is_full_check)
|
|
|
|
add_custom_target(${NAME} ${PARSE_UNPARSED_ARGUMENTS} COMMENT "Building custom test ${NAME}")
|
|
add_test(NAME ${NAME} COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target ${NAME})
|
|
foreach(__environment ${PARSE_ENVIRONMENT})
|
|
set_tests_properties(${NAME} PROPERTIES ENVIRONMENT "${__environment}")
|
|
endforeach()
|
|
|
|
# The tests often change the contents of the user databases, which may affect performance after testing.
|
|
# For example, MIOPEN_DEBUG_FIND_ONLY_SOLVER results in non-optimal records in user-find-db.
|
|
# Another example is tuning tests. These use MIOPEN_DEBUG_TUNING_ITERATIONS_MAX to save testing time,
|
|
# but the side effect of such savings is sub-optimal tuning values in user-perf-db.
|
|
#
|
|
# MIOPEN_USER_DB_PATH setting resolves this potential problem. The user databases are written in
|
|
# the non-default directory. This preserves the state of the actual user databases
|
|
# and prevents performance degradation after the tests complete.
|
|
#
|
|
set_tests_properties(${NAME} PROPERTIES ENVIRONMENT "MIOPEN_USER_DB_PATH=${CMAKE_CURRENT_BINARY_DIR}")
|
|
|
|
if(WORKAROUND_ISSUE_1148
|
|
AND (${NAME} MATCHES "test_conv_3d"
|
|
OR ${NAME} MATCHES "test_conv_group"
|
|
OR ${NAME} MATCHES "test_conv_extra"
|
|
OR ${NAME} MATCHES "test_conv_for_implicit_gemm"
|
|
OR ${NAME} MATCHES "test_conv_ck_igemm_fwd_v6r1_dlops_nchw"))
|
|
set_tests_properties(${NAME} PROPERTIES RUN_SERIAL On)
|
|
endif()
|
|
|
|
if ((is_gfx900_check OR is_gfx906_check OR is_gfx908_check OR is_gfx103x_check OR is_gfx110x_check OR is_gfx115x_check OR is_gfx90a_check OR is_gfx94x_check OR is_gfx95x_check)
|
|
AND is_full_check
|
|
AND is_xnack_on_check
|
|
AND is_mlir_check
|
|
AND is_composablekernel_check
|
|
AND (is_half_check OR is_bfloat16_check OR is_int8_check OR is_tf32_check OR is_float_check)
|
|
AND (is_hip_check AND is_hip_nogpu_check)
|
|
)
|
|
if(PARSE_TEST_PERF_DB_RECORD_NOT_FOUND AND PARSE_TEST_TUNING)
|
|
message(FATAL_ERROR " TEST_PERF_DB_RECORD_NOT_FOUND and TEST_TUNING should not be used together")
|
|
endif()
|
|
|
|
if(PARSE_TEST_PERF_DB_RECORD_NOT_FOUND)
|
|
set_tests_properties(${NAME} PROPERTIES FAIL_REGULAR_EXPRESSION "(FAILED)|(Perf Db: record not found)")
|
|
elseif(PARSE_TEST_TUNING)
|
|
set_tests_properties(${NAME} PROPERTIES FAIL_REGULAR_EXPRESSION "(FAILED)|(Error)|(failed)")
|
|
else()
|
|
set_tests_properties(${NAME} PROPERTIES FAIL_REGULAR_EXPRESSION "FAILED")
|
|
endif()
|
|
|
|
rate_added_test(${NAME})
|
|
else()
|
|
set_tests_properties(${NAME} PROPERTIES DISABLED On)
|
|
endif()
|
|
|
|
if(WORKAROUND_ISSUE_1187
|
|
AND (${NAME} MATCHES "test_conv_for_implicit_gemm" ))
|
|
set_tests_properties(${NAME} PROPERTIES DISABLED On)
|
|
endif()
|
|
endfunction()
|
|
|
|
set(IMPLICITGEMM_MLIR_ENV_BASE MIOPEN_FIND_MODE=normal)
|
|
set(IMPLICITGEMM_MLIR_ENV_F ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmFwd)
|
|
set(IMPLICITGEMM_MLIR_ENV_B ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmBwd)
|
|
set(IMPLICITGEMM_MLIR_ENV_W ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmWrW)
|
|
|
|
set(TEST_CONV_VERBOSE_F ${MIOPEN_TEST_FLOAT_ARG} --verbose --disable-backward-data --disable-backward-weights)
|
|
set(TEST_CONV_VERBOSE_B ${MIOPEN_TEST_FLOAT_ARG} --verbose --disable-forward --disable-backward-weights)
|
|
set(TEST_CONV_VERBOSE_W ${MIOPEN_TEST_FLOAT_ARG} --verbose --disable-forward --disable-backward-data)
|
|
|
|
set(IMPLICITGEMM_MLIR_ENV_F_XDLOPS ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmFwdXdlops)
|
|
set(IMPLICITGEMM_MLIR_ENV_B_XDLOPS ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmBwdXdlops)
|
|
set(IMPLICITGEMM_MLIR_ENV_W_XDLOPS ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmWrWXdlops)
|
|
|
|
set(IMPLICITGEMM_TESTING_ENV
|
|
MIOPEN_DEBUG_CONV_WINOGRAD=0
|
|
MIOPEN_DEBUG_CONV_FFT=0
|
|
MIOPEN_DEBUG_CONV_DIRECT=0
|
|
MIOPEN_DEBUG_CONV_GEMM=0
|
|
MIOPEN_DEBUG_CONV_IMPLICIT_GEMM=1
|
|
)
|
|
|
|
if(MIOPEN_TEST_DEEPBENCH)
|
|
add_custom_test(test_deepbench_rnn GFX94X_ENABLED GFX103X_ENABLED GFX110X_ENABLED GFX115X_ENABLED)
|
|
endif()
|
|
|
|
set(DYNAMIC_IMPLICITGEMM_COMMON
|
|
MIOPEN_FIND_MODE=normal)
|
|
set(DYNAMIC_IMPLICITGEMM_XDLOPS_NHWC_FWD_ENVS
|
|
${DYNAMIC_IMPLICITGEMM_COMMON}
|
|
MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvAsmImplicitGemmGTCDynamicFwdXdlopsNHWC)
|
|
set(DYNAMIC_IMPLICITGEMM_XDLOPS_NHWC_BWD_ENVS
|
|
${DYNAMIC_IMPLICITGEMM_COMMON}
|
|
MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvAsmImplicitGemmGTCDynamicBwdXdlopsNHWC)
|
|
|
|
set(DYNAMIC_IMPLICITGEMM_DLOPS_NCHWC_FWD_ENVS
|
|
${DYNAMIC_IMPLICITGEMM_COMMON}
|
|
MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvAsmImplicitGemmGTCDynamicFwdDlopsNCHWC)
|
|
|
|
set(ARGS_NCHWC_NCHWC_FWD_FP16x4
|
|
--cmode convfp16
|
|
--disable-backward-data
|
|
--disable-backward-weights
|
|
--in_layout NCHW
|
|
--fil_layout NCHW
|
|
--out_layout NCHW
|
|
--tensor_vect 1
|
|
--vector_length 4)
|
|
|
|
set(ARGS_NCHWC_NCHWC_FWD_FP16x8
|
|
--cmode convfp16
|
|
--disable-backward-data
|
|
--disable-backward-weights
|
|
--in_layout NCHW
|
|
--fil_layout NCHW
|
|
--out_layout NCHW
|
|
--tensor_vect 1
|
|
--vector_length 8)
|
|
|
|
set(ARGS_NCHWC_CHWNC_FWD_FP16x4
|
|
--cmode convfp16
|
|
--disable-backward-data
|
|
--disable-backward-weights
|
|
--in_layout NCHW
|
|
--fil_layout CHWN
|
|
--out_layout NCHW
|
|
--tensor_vect 1
|
|
--vector_length 4)
|
|
|
|
set(ARGS_NCHWC_CHWNC_FWD_FP16x8
|
|
--cmode convfp16
|
|
--disable-backward-data
|
|
--disable-backward-weights
|
|
--in_layout NCHW
|
|
--fil_layout CHWN
|
|
--out_layout NCHW
|
|
--tensor_vect 1
|
|
--vector_length 8)
|
|
|
|
add_custom_test(test_regression_issue_2624 SKIP_UNLESS_ALL GFX900_DISABLED GFX906_DISABLED
|
|
# Regression test for SWDEV-433714 (issue 2624)
|
|
ENVIRONMENT ${IMPLICITGEMM_TESTING_ENV} MIOPEN_LOG_LEVEL=5
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${MIOPEN_TEST_FLOAT_ARG} --verbose --input 2 1 22 22 --weights 1 1 4 4 --pads_strides_dilations 1 2 4 4 3 2 --disable-backward-data --disable-backward-weights
|
|
)
|
|
|
|
# MIOPEN_DEBUG_CONV_CK_IGEMM_FWD_V6R1_DLOPS_NCHW is explicitly enabled due to the kernel is disabled by default via #2306
|
|
set(CONV_CK_IGEMM_FWD_V6R1_DLOPS_NCHW_ENV
|
|
MIOPEN_FIND_MODE=normal
|
|
MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvCkIgemmFwdV6r1DlopsNchw
|
|
MIOPEN_DEBUG_CONV_CK_IGEMM_FWD_V6R1_DLOPS_NCHW=1)
|
|
|
|
# NOTES ON WRITING TESTS FOR TUNABLE SOLVERS
|
|
# * Enforce tuning (SEARCH_DB_UPDATE).
|
|
# * Use TEST_TUNING. This flag leads to test failure in case of any "Error"
|
|
# message output to the log, which happens if something is broken in the tuning machinery.
|
|
# * Use MIOPEN_DEBUG_TUNING_ITERATIONS_MAX to save testing time.
|
|
|
|
add_custom_test(smoke_solver_ConvMlirIgemm_F GFX900_DISABLED GFX908_DISABLED GFX90A_DISABLED GFX103X_ENABLED HALF_ENABLED SKIP_UNLESS_MLIR TEST_TUNING
|
|
ENVIRONMENT MIOPEN_FIND_ENFORCE=SEARCH_DB_UPDATE MIOPEN_DEBUG_TUNING_ITERATIONS_MAX=5 ${IMPLICITGEMM_MLIR_ENV_F}
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${TEST_CONV_VERBOSE_F} --input 64 128 14 14 --weights 128 128 1 1 --pads_strides_dilations 0 0 2 2 1 1 --in_layout NHWC --fil_layout NHWC --out_layout NHWC ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(smoke_solver_ConvMlirIgemm_B GFX900_DISABLED GFX908_DISABLED GFX90A_DISABLED GFX103X_ENABLED HALF_ENABLED SKIP_UNLESS_MLIR TEST_TUNING
|
|
ENVIRONMENT MIOPEN_FIND_ENFORCE=SEARCH_DB_UPDATE MIOPEN_DEBUG_TUNING_ITERATIONS_MAX=5 ${IMPLICITGEMM_MLIR_ENV_B}
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${TEST_CONV_VERBOSE_B} --input 64 256 28 28 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1 --group-count 4 ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(smoke_solver_ConvMlirIgemm_W GFX900_DISABLED GFX908_DISABLED GFX90A_DISABLED GFX103X_ENABLED HALF_ENABLED SKIP_UNLESS_MLIR TEST_TUNING
|
|
ENVIRONMENT MIOPEN_FIND_ENFORCE=SEARCH_DB_UPDATE MIOPEN_DEBUG_TUNING_ITERATIONS_MAX=5 ${IMPLICITGEMM_MLIR_ENV_W}
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${TEST_CONV_VERBOSE_W} --input 64 64 28 28 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1 ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(conv_transposed_fwd
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${TEST_CONV_VERBOSE_F} --input 1 16 24 24 --weights 16 16 7 7 --pads_strides_dilations 3 3 1 1 1 1 --cmode transpose ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(conv_transposed_bwd
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${TEST_CONV_VERBOSE_B} --input 64 64 28 28 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1 --cmode transpose ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(conv_transposed_wrw
|
|
COMMAND $<TARGET_FILE:test_conv2d> ${TEST_CONV_VERBOSE_W} --input 64 64 28 28 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1 --cmode transpose ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(conv_transposed_fwd_find_2
|
|
COMMAND $<TARGET_FILE:test_conv2d_find2> ${TEST_CONV_VERBOSE_F} --input 1 16 24 24 --weights 16 16 7 7 --pads_strides_dilations 3 3 1 1 1 1 --cmode transpose ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(conv_transposed_bwd_find_2
|
|
COMMAND $<TARGET_FILE:test_conv2d_find2> ${TEST_CONV_VERBOSE_B} --input 64 64 28 28 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1 --cmode transpose ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
add_custom_test(conv_transposed_wrw_find_2
|
|
COMMAND $<TARGET_FILE:test_conv2d_find2> ${TEST_CONV_VERBOSE_W} --input 64 64 28 28 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1 --cmode transpose ${MIOPEN_TEST_FLAGS_ARGS}
|
|
)
|
|
|
|
#Dont install the tests if we are building each test separately
|
|
#When the tests are built as a single unit, then we want to be
|
|
#able to package them
|
|
set(INSTALL_GTEST OFF)
|
|
if(MIOPEN_TEST_DISCRETE)
|
|
add_subdirectory(gtest EXCLUDE_FROM_ALL)
|
|
else()
|
|
add_subdirectory(gtest)
|
|
endif()
|
|
|
|
# Legacy targets are defined for CI support ONLY. Always use the 'miopen-' targets.
|
|
if(NOT ROCM_LIBS_SUPERBUILD)
|
|
add_custom_target(check DEPENDS miopen-check COMMENT "Back-compat alias for miopen-check")
|
|
add_custom_target(tests DEPENDS miopen-tests COMMENT "Back-compat alias for miopen-tests")
|
|
endif()
|