From 1cefd4eb11a9ad16ca008c18c9754fc5651803a4 Mon Sep 17 00:00:00 2001 From: YuriiPerets Date: Tue, 1 Oct 2024 22:31:44 +0300 Subject: [PATCH] Draft:Adding new filter rule --- src/bashi/filter_software_dependency.py | 35 ++-- src/bashi/results.py | 40 +++-- src/bashi/utils.py | 173 ++++++++++++++++++ src/bashi/versions.py | 10 ++ tests/test_filter_software_dependency.py | 212 ++++++++++++++++++++--- tests/test_results.py | 30 ++-- 6 files changed, 439 insertions(+), 61 deletions(-) diff --git a/src/bashi/filter_software_dependency.py b/src/bashi/filter_software_dependency.py index 988b5ef..051fdf7 100644 --- a/src/bashi/filter_software_dependency.py +++ b/src/bashi/filter_software_dependency.py @@ -13,7 +13,6 @@ from bashi.types import ParameterValueTuple from bashi.globals import * # pylint: disable=wildcard-import,unused-wildcard-import from bashi.utils import reason -from bashi.versions import CLANG_CUDA_MAX_CUDA_VERSION def __ubuntu_version_to_string(version: pkv.Version) -> str: @@ -120,25 +119,11 @@ def software_dependency_filter( return True # Rule: d4 - # Ubuntu 20.04 and newer is not available with CUDA older than 10.2 - - """ - if UBUNTU in row and row[UBUNTU].version >= pkv.parse("20.04"): - if ALPAKA_ACC_GPU_CUDA_ENABLE in row and row[ALPAKA_ACC_GPU_CUDA_ENABLE].version != OFF_VER: - if row[ALPAKA_ACC_GPU_CUDA_ENABLE].version < pkv.parse("10.2"): - reason( - output, - f"CUDA {row[ALPAKA_ACC_GPU_CUDA_ENABLE].version} " - "is not available in Ubuntu " - f"{__ubuntu_version_to_string(row[UBUNTU].version)}", - ) - return False - - """ + # Ubuntu 20.04 and newer is not available with CUDA older than 11 if UBUNTU in row and row[UBUNTU].version >= pkv.parse("20.04"): if ALPAKA_ACC_GPU_CUDA_ENABLE in row and row[ALPAKA_ACC_GPU_CUDA_ENABLE].version != OFF_VER: - if row[ALPAKA_ACC_GPU_CUDA_ENABLE].version < pkv.parse("11"): + if row[ALPAKA_ACC_GPU_CUDA_ENABLE].version < pkv.parse("11.0"): reason( output, f"CUDA {row[ALPAKA_ACC_GPU_CUDA_ENABLE].version} " @@ -147,9 +132,21 @@ def software_dependency_filter( ) return False if DEVICE_COMPILER in row and row[DEVICE_COMPILER].name == NVCC: - if row[DEVICE_COMPILER].version < pkv.parse("11"): + if row[DEVICE_COMPILER].version < pkv.parse("11.0"): + reason( + output, + f"NVCC {row[DEVICE_COMPILER].version} " + "is not available in Ubuntu " + f"{__ubuntu_version_to_string(row[UBUNTU].version)}", + ) return False for compiler in (HOST_COMPILER, DEVICE_COMPILER): if compiler in row and row[compiler].name == CLANG_CUDA: - if row[compiler].version < CLANG_CUDA_MAX_CUDA_VERSION[3].clang_cuda: + if row[compiler].version < get_max_supported_clang_cuda_ver("11.0"): + reason( + output, + f"clang cuda {row[compiler].version} " + "is not available in Ubuntu " + f"{__ubuntu_version_to_string(row[UBUNTU].version)}", + ) return False diff --git a/src/bashi/results.py b/src/bashi/results.py index a2d7738..b6d8dff 100644 --- a/src/bashi/results.py +++ b/src/bashi/results.py @@ -4,7 +4,12 @@ from typeguard import typechecked from packaging.specifiers import SpecifierSet from bashi.types import ParameterValuePair, ParameterValueMatrix -from bashi.utils import get_expected_parameter_value_pairs, remove_parameter_value_pairs, bi_filter +from bashi.utils import ( + remove_parameter_value_pairs_ranges, + get_expected_parameter_value_pairs, + remove_parameter_value_pairs, + bi_filter, +) from bashi.globals import * # pylint: disable=wildcard-import,unused-wildcard-import from bashi.versions import ( COMPILERS, @@ -834,35 +839,50 @@ def _remove_unsupported_cuda_versions_for_ubuntu( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=UBUNTU, value_name1=UBUNTU, - value_version1="<20.04", + value_min_version1=20.04, + value_min_version1_inclusive=True, + value_max_version1=9999, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2=">11", + value_min_version2=OFF, + value_min_version2_inclusive=False, + value_max_version2=11, + value_max_version2_inclusive=True, ) - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=UBUNTU, value_name1=UBUNTU, - value_version1="<20.04", + value_min_version1=20.04, + value_min_version1_inclusive=True, + value_max_version1=9999, parameter2=DEVICE_COMPILER, value_name2=NVCC, - value_version2=">11", + value_min_version2=OFF, + value_min_version2_inclusive=False, + value_max_version2=11, + value_max_version2_inclusive=False, ) for compiler_type in (HOST_COMPILER, DEVICE_COMPILER): - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=UBUNTU, value_name1=UBUNTU, - value_version1="<20.04", + value_min_version1=20.04, + value_min_version1_inclusive=True, + value_max_version1=9999, parameter2=compiler_type, value_name2=CLANG_CUDA, - value_version2=">12", + value_min_version2=OFF, + value_min_version2_inclusive=False, + value_max_version2=12, + value_max_version2_inclusive=False, ) diff --git a/src/bashi/utils.py b/src/bashi/utils.py index b868a2a..1eea828 100644 --- a/src/bashi/utils.py +++ b/src/bashi/utils.py @@ -484,3 +484,176 @@ def print_row_nice( f"{nice_version.get(val.version, str(val.version))} " ) print(s) + + +def _create_version_range( + min_version: Union[int, float, str], + min_version_inclusive: bool, + max_version: Union[int, float, str], + max_version_inclusive: bool, +) -> SpecifierSet: + """Creates Version SpecifierSet depending on the input. + Args: + min_version (Union[int, float, str]): Minimum version of the version range. Must be able + to be parsed into a `packaging.version.Version`. Use `ANY_VERSION` if the minimum range + should be open and every check for minimum version should return true. + min_version_inclusive (bool): If True, the minimum version is within the range and a check + for minimum version results in True. If False, the check for the minimum version results + in False. + max_version (Union[int, float, str]): Maximum version of the version range. Must be able + to be parsed into a `packaging.version.Version`. Use `ANY_VERSION` if the maximum range + should be open and every check for maximum version should return true. + max_version_inclusive (bool): If True, the maximum version is within the range and a check + for maximum version results in True. If False, the check for the maximum version results + in False. + Returns: + SpecifierSet: A SpecifierSet which can be used to check if version is inside the created + range. + """ + # if empty, it matches all versions + min_range = SpecifierSet() + max_range = SpecifierSet() + + if min_version != ANY_VERSION: + # check if valid version number + packaging.version.parse(str(min_version)) + min_range = SpecifierSet( + ">=" + str(min_version) if min_version_inclusive else ">" + str(min_version) + ) + + if max_version != ANY_VERSION: + # check if valid version number + packaging.version.parse(str(max_version)) + max_range = SpecifierSet( + "<=" + str(max_version) if max_version_inclusive else "<" + str(max_version) + ) + + return min_range & max_range + + +@typechecked +def remove_parameter_value_pairs_ranges( # pylint: disable=too-many-arguments + parameter_value_pairs: List[ParameterValuePair], + removed_parameter_value_pairs: List[ParameterValuePair], + parameter1: Parameter = ANY_PARAM, + value_name1: ValueName = ANY_NAME, + value_min_version1: Union[int, float, str] = ANY_VERSION, + value_min_version1_inclusive: bool = True, + value_max_version1: Union[int, float, str] = ANY_VERSION, + value_max_version1_inclusive: bool = True, + parameter2: Parameter = ANY_PARAM, + value_name2: ValueName = ANY_NAME, + value_min_version2: Union[int, float, str] = ANY_VERSION, + value_min_version2_inclusive: bool = True, + value_max_version2: Union[int, float, str] = ANY_VERSION, + value_max_version2_inclusive: bool = True, + symmetric: bool = True, +) -> bool: + """Removes all elements from `parameter_value_pairs` and moves them to + `removed_parameter_value_pairs` if certain filter requirements are met. The filter properties + are defined for the first and/or second parameter-value in a parameter-value-pair. All entries + that meet all requirements are removed from “parameter_value_pairs”. + The default values `ANY_PARAM`, `ANY_NAME` and `ANY_VERSION` match all values of each property, + which means if each argument is set to default, all elements of `parameter_value_pairs` are + removed.c + Parameter and value-name are checked for equality. + value_min_version and value_max_version allow you to define a version range that is to be + removed. By default, the version range is open in both directions (minimum and maximum version) + and can be restricted. If the version range is defined for both parameter values, the pair must + match both version ranges for it to be removed. + Args: + parameter_value_pairs (List[ParameterValuePair]): list where parameter-value-pairs will be + removed + removed_parameter_value_pairs (List[ParameterValuePair]): list where removed + parameter-value-pairs will be stored + parameter1 (Parameter, optional): Name of the first parameter. Defaults to ANY_PARAM. + value_name1 (ValueName, optional): Name of the first value-name. Defaults to ANY_NAME. + value_min_version1 (Union[int, float, str], optional): Minimum version of the version range + of the first value-version. All versions that are greater than this version are removed. + Defaults to ANY_VERSION. + value_min_version1_inclusive (bool, optional): If True, `value_min_version1` is removed. + Otherwise, all versions greater than `value_min_version1` are removed. Defaults to True. + value_max_version1 (Union[int, float, str], optional): Maximum version of the version range + of the first value-version. All versions that are smaller than this version are removed. + Defaults to ANY_VERSION. + value_max_version1_inclusive (bool, optional): If True, `value_max_version1` is removed. + Otherwise, all versions smaller than `value_max_version1` are removed. Defaults to True. + parameter2 (Parameter, optional): _description_. Defaults to ANY_PARAM. + value_name2 (ValueName, optional): _description_. Defaults to ANY_NAME. + value_min_version2 (Union[int, float, str], optional): Minimum version of the version range + of the second value-version. All versions that are greater than this version are + removed. Defaults to ANY_VERSION. + value_min_version2_inclusive (bool, optional): If True, `value_min_version2` is removed. + Otherwise, all versions greater than `value_min_version2` are removed. Defaults to True. + value_max_version2 (Union[int, float, str], optional): Maximum version of the version range + of the second value-version. All versions that are smaller than this version are + removed. Defaults to ANY_VERSION. + value_max_version2_inclusive (bool, optional): If True, `value_max_version2` is removed. + Otherwise, all versions smaller than `value_max_version2` are removed. Defaults to True. + symmetric (bool, optional): If symmetric is true, it does not matter whether a group of + parameters, value-name and value-version was found in the first or second + parameter-value. If false, it is taken into account whether the search criterion was + found in the first or second parameter value. Defaults to True. + Returns: + bool: Return True, if parameter-value-pair was removed. + """ + filter_list: List[Callable[[ParameterValuePair], bool]] = [] + if parameter1 != ANY_PARAM: + filter_list.append(lambda param_val: param_val.first.parameter == parameter1) + + if value_name1 != ANY_NAME: + filter_list.append(lambda param_val: param_val.first.parameterValue.name == value_name1) + + if parameter2 != ANY_PARAM: + filter_list.append(lambda param_val: param_val.second.parameter == parameter2) + + if value_name2 != ANY_NAME: + filter_list.append(lambda param_val: param_val.second.parameterValue.name == value_name2) + + range_ver1 = _create_version_range( + value_min_version1, + value_min_version1_inclusive, + value_max_version1, + value_max_version1_inclusive, + ) + filter_list.append(lambda param_val: param_val.first.parameterValue.version in range_ver1) + + range_ver2 = _create_version_range( + value_min_version2, + value_min_version2_inclusive, + value_max_version2, + value_max_version2_inclusive, + ) + filter_list.append(lambda param_val: param_val.second.parameterValue.version in range_ver2) + + def filter_func(param_value_pair: ParameterValuePair) -> bool: + return_value = True + + for f in filter_list: + return_value = return_value and f(param_value_pair) + + return not return_value + + len_before = len(parameter_value_pairs) + bi_filter(parameter_value_pairs, removed_parameter_value_pairs, filter_func) + + if symmetric: + remove_parameter_value_pairs_ranges( + parameter_value_pairs, + removed_parameter_value_pairs, + parameter2, + value_name2, + value_min_version2, + value_min_version2_inclusive, + value_max_version2, + value_max_version2_inclusive, + parameter1, + value_name1, + value_min_version1, + value_min_version1_inclusive, + value_max_version1, + value_max_version1_inclusive, + symmetric=False, + ) + + return len_before != len(parameter_value_pairs) diff --git a/src/bashi/versions.py b/src/bashi/versions.py index 80c83bf..afea9aa 100644 --- a/src/bashi/versions.py +++ b/src/bashi/versions.py @@ -232,3 +232,13 @@ def is_supported_version(name: ValueName, version: ValueVersion) -> bool: return True return False + + +def get_max_supported_clang_cuda_ver(cuda_version: str) -> str: + """Returns the latest supported Clang-CUDA version for a given CUDA version.""" + parsed_cuda_ver = pkv.parse(cuda_version) + + for sdk_support in CLANG_CUDA_MAX_CUDA_VERSION: + if pkv.parse(sdk_support.cuda) == parsed_cuda_ver: + max_clang_cuda_ver = pkv.parse(sdk_support.clang_cuda) + return max_clang_cuda_ver diff --git a/tests/test_filter_software_dependency.py b/tests/test_filter_software_dependency.py index 3cf098c..2a89f6e 100644 --- a/tests/test_filter_software_dependency.py +++ b/tests/test_filter_software_dependency.py @@ -190,7 +190,7 @@ def test_not_valid_cmake_versions_for_clangcuda_d2(self): f"device compiler CLANG_CUDA is not available in CMAKE {cmake_version}", ) - def test_valid_ROCm_images_Ubuntu2004_based_d4(self): + def test_valid_ROCm_images_Ubuntu2004_based_d3(self): for UBUNTU_version in ["20.04", "22.04", "21.04"]: self.assertTrue( software_dependency_filter_typechecked( @@ -227,7 +227,7 @@ def test_valid_ROCm_images_Ubuntu2004_based_d4(self): ), ) - def test_non_valid_ROCm_images_Ubuntu2004_based_d4(self): + def test_non_valid_ROCm_images_Ubuntu2004_based_d3(self): for UBUNTU_version in ["16.04", "18.04", "19.04"]: reason_msg = io.StringIO() self.assertFalse( @@ -303,8 +303,8 @@ def test_non_valid_ROCm_images_Ubuntu2004_based_d4(self): f"{test_row}", ) - def test_valid_cuda_versions_for_ubuntu_d3(self): - for CUDA_version in [10.2, 11.4, 15]: + def test_valid_cuda_versions_for_ubuntu_d4(self): + for CUDA_version in [11.1, 11.4, 15]: self.assertTrue( software_dependency_filter_typechecked( OD( @@ -318,6 +318,7 @@ def test_valid_cuda_versions_for_ubuntu_d3(self): ) ) + for CUDA_version in [11.2, 11.4, 15]: self.assertTrue( software_dependency_filter_typechecked( OD( @@ -325,12 +326,12 @@ def test_valid_cuda_versions_for_ubuntu_d3(self): ALPAKA_ACC_GPU_CUDA_ENABLE: ppv( (ALPAKA_ACC_GPU_CUDA_ENABLE, CUDA_version) ), - UBUNTU: ppv((UBUNTU, "22.04")), + UBUNTU: ppv((UBUNTU, "20.04")), } ), ) ) - for CUDA_version in [10.2, 11.4, 15]: + for CUDA_version in [2, 6, 10.1, 10.2, 11.4, 15]: self.assertTrue( software_dependency_filter_typechecked( OD( @@ -338,52 +339,113 @@ def test_valid_cuda_versions_for_ubuntu_d3(self): ALPAKA_ACC_GPU_CUDA_ENABLE: ppv( (ALPAKA_ACC_GPU_CUDA_ENABLE, CUDA_version) ), - UBUNTU: ppv((UBUNTU, "20.04")), + UBUNTU: ppv((UBUNTU, "18.04")), } ), ) ) + for nvcc_version in [2, 6, 10.1, 10.2, 11.4, 15]: self.assertTrue( software_dependency_filter_typechecked( OD( { - ALPAKA_ACC_GPU_CUDA_ENABLE: ppv( - (ALPAKA_ACC_GPU_CUDA_ENABLE, CUDA_version) - ), + DEVICE_COMPILER: ppv((DEVICE_COMPILER, nvcc_version)), + UBUNTU: ppv((UBUNTU, "18.04")), + } + ), + ) + ) + for nvcc_version in [11.1, 11.2, 11.4, 15]: + self.assertTrue( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, nvcc_version)), UBUNTU: ppv((UBUNTU, "20.04")), } ), ) ) - for CUDA_version in [2, 6, 10.1, 10.2, 11.4, 15]: + for nvcc_version in [11.1, 11.2, 11.4, 15]: self.assertTrue( software_dependency_filter_typechecked( OD( { - ALPAKA_ACC_GPU_CUDA_ENABLE: ppv( - (ALPAKA_ACC_GPU_CUDA_ENABLE, CUDA_version) - ), + DEVICE_COMPILER: ppv((DEVICE_COMPILER, nvcc_version)), + UBUNTU: ppv((UBUNTU, "22.04")), + } + ), + ) + ) + for clang_cuda_version in [2, 6, 10.1, 10.2, 11, 12.4, 15]: + self.assertTrue( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, clang_cuda_version)), UBUNTU: ppv((UBUNTU, "18.04")), } ), ) ) - + for clang_cuda_version in [2, 6, 10.1, 10.2, 11]: self.assertTrue( software_dependency_filter_typechecked( OD( { - ALPAKA_ACC_GPU_CUDA_ENABLE: ppv( - (ALPAKA_ACC_GPU_CUDA_ENABLE, CUDA_version) - ), + DEVICE_COMPILER: ppv((DEVICE_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "20.04")), + } + ), + ) + ) + for clang_cuda_version in [2, 6, 10.1, 10.2, 11]: + self.assertTrue( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "22.04")), + } + ), + ) + ) + for clang_cuda_version in [2, 6, 10.1, 10.2, 11, 12.4, 15]: + self.assertTrue( + software_dependency_filter_typechecked( + OD( + { + HOST_COMPILER: ppv((HOST_COMPILER, clang_cuda_version)), UBUNTU: ppv((UBUNTU, "18.04")), } ), ) ) + for clang_cuda_version in [2, 6, 10.1, 10.2, 11]: + self.assertTrue( + software_dependency_filter_typechecked( + OD( + { + HOST_COMPILER: ppv((HOST_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "20.04")), + } + ), + ) + ) + for clang_cuda_version in [2, 6, 10.1, 10.2, 11]: + self.assertTrue( + software_dependency_filter_typechecked( + OD( + { + HOST_COMPILER: ppv((HOST_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "22.04")), + } + ), + ) + ) - def test_not_valid_cuda_versions_for_ubuntu_d3(self): + def test_not_valid_cuda_versions_for_ubuntu_d4(self): for CUDA_version in [1, 6, 10.1]: reason_msg = io.StringIO() self.assertFalse( @@ -404,7 +466,7 @@ def test_not_valid_cuda_versions_for_ubuntu_d3(self): reason_msg.getvalue(), f"CUDA {CUDA_version} is not available in Ubuntu 20.04", ) - for gcc_version in [1, 6, 10.1]: + for CUDA_version in [1, 6, 10.1]: reason_msg = io.StringIO() self.assertFalse( software_dependency_filter_typechecked( @@ -424,3 +486,113 @@ def test_not_valid_cuda_versions_for_ubuntu_d3(self): reason_msg.getvalue(), f"CUDA {CUDA_version} is not available in Ubuntu 22.04", ) + for nvcc_version in [1, 6, 10.1]: + reason_msg = io.StringIO() + self.assertFalse( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, nvcc_version)), + UBUNTU: ppv((UBUNTU, "20.04")), + } + ), + reason_msg, + ), + f"NVCC {nvcc_version} is not available in Ubuntu 20.04", + ) + self.assertEqual( + reason_msg.getvalue(), + f"NVCC {nvcc_version} is not available in Ubuntu 20.04", + ) + for nvcc_version in [1, 6, 10.1]: + reason_msg = io.StringIO() + self.assertFalse( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, nvcc_version)), + UBUNTU: ppv((UBUNTU, "22.04")), + } + ), + reason_msg, + ), + f"NVCC {nvcc_version} is not available in Ubuntu 22.04", + ) + self.assertEqual( + reason_msg.getvalue(), + f"NVCC {nvcc_version} is not available in Ubuntu 22.04", + ) + + for clang_cuda_version in [1, 6, 10.1]: + reason_msg = io.StringIO() + self.assertFalse( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "22.04")), + } + ), + reason_msg, + ), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 22.04", + ) + self.assertEqual( + reason_msg.getvalue(), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 22.04", + ) + for clang_cuda_version in [1, 6, 10.1]: + reason_msg = io.StringIO() + self.assertFalse( + software_dependency_filter_typechecked( + OD( + { + HOST_COMPILER: ppv((HOST_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "22.04")), + } + ), + reason_msg, + ), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 22.04", + ) + self.assertEqual( + reason_msg.getvalue(), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 22.04", + ) + + for clang_cuda_version in [1, 6, 10.1]: + reason_msg = io.StringIO() + self.assertFalse( + software_dependency_filter_typechecked( + OD( + { + DEVICE_COMPILER: ppv((DEVICE_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "20.04")), + } + ), + reason_msg, + ), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 20.04", + ) + self.assertEqual( + reason_msg.getvalue(), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 20.04", + ) + for clang_cuda_version in [1, 6, 10.1]: + reason_msg = io.StringIO() + self.assertFalse( + software_dependency_filter_typechecked( + OD( + { + HOST_COMPILER: ppv((HOST_COMPILER, clang_cuda_version)), + UBUNTU: ppv((UBUNTU, "20.04")), + } + ), + reason_msg, + ), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 20.04", + ) + self.assertEqual( + reason_msg.getvalue(), + f"clang cuda {clang_cuda_version} is not available in Ubuntu 20.04", + ) diff --git a/tests/test_results.py b/tests/test_results.py index 58b3f68..85b1859 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -2583,12 +2583,6 @@ def test_remove_unsupported_cuda_versions_for_ubuntu(self): DEVICE_COMPILER: (NVCC, "10"), } ), - OD( - { - UBUNTU: (UBUNTU, "22.04"), - DEVICE_COMPILER: (NVCC, "10"), - } - ), OD( { UBUNTU: (UBUNTU, "20.04"), @@ -2619,6 +2613,18 @@ def test_remove_unsupported_cuda_versions_for_ubuntu(self): DEVICE_COMPILER: (CLANG_CUDA, "13"), } ), + OD( + { + UBUNTU: (UBUNTU, "18.04"), + DEVICE_COMPILER: (NVCC, "10.2"), + } + ), + OD( + { + UBUNTU: (UBUNTU, "20.04"), + DEVICE_COMPILER: (NVCC, "10.2"), + } + ), ] ) expected_results = parse_expected_val_pairs( @@ -2641,6 +2647,12 @@ def test_remove_unsupported_cuda_versions_for_ubuntu(self): DEVICE_COMPILER: (CLANG_CUDA, "13"), } ), + OD( + { + UBUNTU: (UBUNTU, "18.04"), + DEVICE_COMPILER: (NVCC, "10.2"), + } + ), OD( { UBUNTU: (UBUNTU, "18.04"), @@ -2671,12 +2683,6 @@ def test_remove_unsupported_cuda_versions_for_ubuntu(self): ALPAKA_ACC_GPU_CUDA_ENABLE: (ALPAKA_ACC_GPU_CUDA_ENABLE, OFF), } ), - OD( - { - UBUNTU: (UBUNTU, "20.04"), - ALPAKA_ACC_GPU_CUDA_ENABLE: (ALPAKA_ACC_GPU_CUDA_ENABLE, "10.2"), - } - ), OD( { UBUNTU: (UBUNTU, "18.04"),