From ac63178629014ac780dadbfb26d5572ef4c63b44 Mon Sep 17 00:00:00 2001 From: Simeon Ehrig Date: Sat, 21 Sep 2024 13:36:05 +0200 Subject: [PATCH 1/6] implement remove_parameter_value_pairs_ranges() - remove_parameter_value_pairs_ranges() allows to remove parameter-value-pairs from a list of parameter-value-pairs. The filter requirements can be set via different arguments. - Replace the function remove_parameter_value_pairs() as easier to use alternative. --- src/bashi/utils.py | 180 ++++ src/bashi/versions.py | 8 +- ...est_remove_parameter_value_pairs_ranges.py | 873 ++++++++++++++++++ tests/utils_test.py | 2 +- 4 files changed, 1058 insertions(+), 5 deletions(-) create mode 100644 tests/test_remove_parameter_value_pairs_ranges.py diff --git a/src/bashi/utils.py b/src/bashi/utils.py index b868a2a..6dda369 100644 --- a/src/bashi/utils.py +++ b/src/bashi/utils.py @@ -484,3 +484,183 @@ 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..8f8e1d0 100644 --- a/src/bashi/versions.py +++ b/src/bashi/versions.py @@ -40,8 +40,8 @@ class NvccHostSupport(VersionSupportBase): def __init__(self, nvcc_version: str, host_version: str): VersionSupportBase.__init__(self, nvcc_version, host_version) - self.nvcc = self.version1 - self.host = self.version2 + self.nvcc: packaging.version.Version = self.version1 + self.host: packaging.version.Version = self.version2 def __str__(self) -> str: return f"nvcc {str(self.nvcc)} + host version {self.host}" @@ -57,8 +57,8 @@ class ClangCudaSDKSupport(VersionSupportBase): def __init__(self, clang_cuda_version: str, cuda_version: str): VersionSupportBase.__init__(self, clang_cuda_version, cuda_version) - self.clang_cuda = self.version1 - self.cuda = self.version2 + self.clang_cuda: packaging.version.Version = self.version1 + self.cuda: packaging.version.Version = self.version2 def __str__(self) -> str: return f"Clang-CUDA {str(self.clang_cuda)} + CUDA SDK {self.cuda}" diff --git a/tests/test_remove_parameter_value_pairs_ranges.py b/tests/test_remove_parameter_value_pairs_ranges.py new file mode 100644 index 0000000..aeab1e3 --- /dev/null +++ b/tests/test_remove_parameter_value_pairs_ranges.py @@ -0,0 +1,873 @@ +# pylint: disable=missing-docstring +import unittest +from typing import List, Union, Tuple +from collections import OrderedDict as OD +from packaging.specifiers import SpecifierSet +import packaging.version as pkv +from copy import deepcopy +from itertools import product + + +from bashi.globals import * # pylint: disable=wildcard-import,unused-wildcard-import +from bashi.types import ParameterValuePair +from bashi.utils import _create_version_range, remove_parameter_value_pairs_ranges + +from utils_test import parse_expected_val_pairs, create_diff_parameter_value_pairs + + +def bool_map(length: int): + return [ele for ele in product([True, False], repeat=length)] + + +class TestCreateVersionRange(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.test_min_max_range_expected: List[Tuple[Union[int, float, str], bool]] = [ + ("5.0.0", False), + ("5.0.2", True), + ("5.1.0", True), + (9, True), + (9.2, True), + (9.4, False), + (10, False), + ("7.0.0", True), + (81, False), + (3, False), + (4.3, False), + (10.01, False), + ("7.0.1", True), + ("9.9.9", False), + ] + + def test_min_max_any_version_type(self): + expected_range = SpecifierSet() & SpecifierSet() + for inclusive_min, inclusive_max in [ + (True, True), + (True, False), + (False, True), + (False, False), + ]: + self.assertEqual( + expected_range, + _create_version_range(ANY_VERSION, inclusive_min, ANY_VERSION, inclusive_max), + ) + + def test_min_max_any_version_match(self): + v_range = _create_version_range(ANY_VERSION, True, ANY_VERSION, True) + for ver in [1, 67, 4.5, 34.4, "1.0.0", "345.34", "0"]: + self.assertTrue(pkv.parse(str(ver)) in v_range) + + def test_min_range_inclusive(self): + v_range = _create_version_range(7, True, ANY_VERSION, True) + + for ver, expected in [ + (6, False), + (7, True), + (7.0, True), + ("7.0.0", True), + (8, True), + (3, False), + (4.3, False), + (7.01, True), + ("7.0.1", True), + ("6.9.9", False), + ]: + self.assertEqual(pkv.parse(str(ver)) in v_range, expected, f"{ver} -> {expected}") + + def test_min_range_exclusive(self): + v_range = _create_version_range(7, False, ANY_VERSION, True) + + for ver, expected in [ + (6, False), + (7, False), + (7.0, False), + ("7.0.0", False), + (8, True), + (3, False), + (4.3, False), + (7.01, True), + ("7.0.1", True), + ("6.9.9", False), + ]: + self.assertEqual(pkv.parse(str(ver)) in v_range, expected, f"{ver} -> {expected}") + + v_range_2 = _create_version_range("7.0.1", False, ANY_VERSION, True) + + for ver, expected in [ + (6, False), + (7, False), + (7.0, False), + ("7.0.0", False), + (8, True), + ("7.0.1", False), + ("7.0.2", True), + ("7.1.0", True), + ]: + self.assertEqual(pkv.parse(str(ver)) in v_range_2, expected, f"{ver} -> {expected}") + + def test_max_range_inclusive(self): + v_range = _create_version_range(ANY_VERSION, True, 13.1, True) + + for ver, expected in [ + (13, True), + (13.1, True), + (13.2, False), + ("7.0.0", True), + (8, True), + (3, True), + (44.3, False), + (7.01, True), + ("17.0.1", False), + ("13.1.1", False), + ]: + self.assertEqual(pkv.parse(str(ver)) in v_range, expected, f"{ver} -> {expected}") + + def test_max_range_exclusive(self): + v_range = _create_version_range(ANY_VERSION, True, 9, False) + + for ver, expected in [ + (8, True), + (9, False), + (10, False), + ("7.0.0", True), + (81, False), + (3, True), + (4.3, True), + (10.01, False), + ("7.0.1", True), + ("9.9.9", False), + ]: + self.assertEqual(pkv.parse(str(ver)) in v_range, expected, f"{ver} -> {expected}") + + def test_min_max_range(self): + for inclusive_min, inclusive_max in [ + (True, True), + (True, False), + (False, True), + (False, False), + ]: + v_range = _create_version_range("5.0.1", inclusive_min, 9.3, inclusive_max) + + test_range_expected: List[Tuple[Union[int, float, str], bool]] = [] + test_range_expected[:] = self.test_min_max_range_expected + test_range_expected.append(("5.0.1", inclusive_min)) + test_range_expected.append( + (9.3, inclusive_max), + ) + + for ver, expected in test_range_expected: + self.assertEqual( + pkv.parse(str(ver)) in v_range, + expected, + f"\ninclusive_min: {inclusive_min}, inclusive_max: {inclusive_max}\n" + f"{ver} -> {expected}", + ) + + +class TestRemoveParameterValuePairsRanges(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.parameter_test_data: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD( + { + HOST_COMPILER: (GCC, 10), + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE: ( + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE, + ON, + ), + } + ), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + ] + ) + # reuse data for parameter-value-names + cls.name_test_data = cls.parameter_test_data + + cls.version_test_data: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.5)}), + # corner case GCC min version + OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 12), DEVICE_COMPILER: (NVCC, 11.5)}), + # corner case GCC max version + OD({HOST_COMPILER: (GCC, 13), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 14), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 10.2)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.2)}), + # corner case NVCC min version + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.3)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.4)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.6)}), + # corner case NVCC max version + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.7)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.8)}), + ] + ) + + def test_remove_parameter_value_pairs_ranges_all_any(self): + test_parameter_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD( + { + HOST_COMPILER: (GCC, 10), + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE: ( + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE, + ON, + ), + } + ), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + ] + ) + + expected_removed: List[ParameterValuePair] = [] + expected_removed[:] = sorted(test_parameter_value_pairs) + + remove_list: List[ParameterValuePair] = [] + remove_parameter_value_pairs_ranges(test_parameter_value_pairs, remove_list) + + test_parameter_value_pairs.sort() + remove_list.sort() + + self.assertEqual(test_parameter_value_pairs, []) + self.assertEqual(remove_list, expected_removed) + + def test_remove_parameter_value_pairs_ranges_remove_first_parameter(self): + symmetric_test_data = deepcopy(self.parameter_test_data) + symmetric_expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + ] + ) + ) + symmetric_expected_remove = sorted( + list(set(symmetric_test_data) - set(symmetric_expected_result)) + ) + symmetric_remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + symmetric_test_data, symmetric_remove, parameter1=HOST_COMPILER + ) + + symmetric_test_data.sort() + symmetric_remove.sort() + + self.assertEqual( + symmetric_test_data, + symmetric_expected_result, + create_diff_parameter_value_pairs(symmetric_test_data, symmetric_expected_result), + ) + self.assertEqual( + symmetric_remove, + symmetric_expected_remove, + create_diff_parameter_value_pairs(symmetric_remove, symmetric_expected_remove), + ) + + non_symmetric_test_data = deepcopy(self.parameter_test_data) + non_symmetric_expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + ] + ) + ) + non_symmetric_expected_remove = sorted( + list(set(non_symmetric_test_data) - set(non_symmetric_expected_result)) + ) + non_symmetric_remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + non_symmetric_test_data, non_symmetric_remove, parameter1=HOST_COMPILER, symmetric=False + ) + + non_symmetric_test_data.sort() + non_symmetric_remove.sort() + + self.assertEqual( + non_symmetric_test_data, + non_symmetric_expected_result, + create_diff_parameter_value_pairs( + non_symmetric_test_data, non_symmetric_expected_result + ), + ) + self.assertEqual( + non_symmetric_remove, + non_symmetric_expected_remove, + create_diff_parameter_value_pairs(non_symmetric_remove, non_symmetric_expected_remove), + ) + + def test_remove_parameter_value_pairs_ranges_remove_second_parameter(self): + symmetric_test_data = deepcopy(self.parameter_test_data) + symmetric_expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD( + { + HOST_COMPILER: (GCC, 10), + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE: ( + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE, + ON, + ), + } + ), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + ] + ) + ) + symmetric_expected_remove = sorted( + list(set(symmetric_test_data) - set(symmetric_expected_result)) + ) + symmetric_remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + symmetric_test_data, symmetric_remove, parameter2=DEVICE_COMPILER + ) + + symmetric_test_data.sort() + symmetric_remove.sort() + + self.assertEqual( + symmetric_test_data, + symmetric_expected_result, + create_diff_parameter_value_pairs(symmetric_test_data, symmetric_expected_result), + ) + self.assertEqual( + symmetric_remove, + symmetric_expected_remove, + create_diff_parameter_value_pairs(symmetric_remove, symmetric_expected_remove), + ) + + non_symmetric_test_data = deepcopy(self.parameter_test_data) + non_symmetric_expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD( + { + HOST_COMPILER: (GCC, 10), + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE: ( + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE, + ON, + ), + } + ), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + ] + ) + ) + non_symmetric_expected_remove = sorted( + list(set(non_symmetric_test_data) - set(non_symmetric_expected_result)) + ) + non_symmetric_remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + non_symmetric_test_data, + non_symmetric_remove, + parameter2=DEVICE_COMPILER, + symmetric=False, + ) + + non_symmetric_test_data.sort() + non_symmetric_remove.sort() + + self.assertEqual( + non_symmetric_test_data, + non_symmetric_expected_result, + create_diff_parameter_value_pairs( + non_symmetric_test_data, non_symmetric_expected_result + ), + ) + self.assertEqual( + non_symmetric_remove, + non_symmetric_expected_remove, + create_diff_parameter_value_pairs(non_symmetric_remove, non_symmetric_expected_remove), + ) + + def test_remove_parameter_value_pairs_ranges_remove_both_parameter(self): + test_data = deepcopy(self.parameter_test_data) + expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD( + { + HOST_COMPILER: (GCC, 10), + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE: ( + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE, + ON, + ), + } + ), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + ] + ) + ) + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, remove, parameter1=HOST_COMPILER, parameter2=DEVICE_COMPILER + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + def test_remove_parameter_value_pairs_ranges_remove_single_name(self): + test_data = deepcopy(self.name_test_data) + expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + ] + ) + ) + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, remove, parameter1=HOST_COMPILER, value_name1=GCC + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + name2_test_data = deepcopy(self.name_test_data) + name2_remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + name2_test_data, name2_remove, parameter2=HOST_COMPILER, value_name2=GCC + ) + name2_test_data.sort() + name2_remove.sort() + + self.assertEqual( + name2_test_data, + test_data, + create_diff_parameter_value_pairs(name2_test_data, test_data), + ) + self.assertEqual( + name2_remove, + remove, + create_diff_parameter_value_pairs(name2_remove, remove), + ) + + def test_remove_parameter_value_pairs_ranges_remove_both_name(self): + test_data = deepcopy(self.name_test_data) + expected_result = sorted( + parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD( + { + HOST_COMPILER: (GCC, 10), + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE: ( + ALPAKA_ACC_CPU_B_OMP2_T_SEQ_ENABLE, + ON, + ), + } + ), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + ] + ) + ) + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, + remove, + parameter1=HOST_COMPILER, + value_name1=GCC, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + # remove all elements up to a minimum version + def test_remove_parameter_value_pairs_ranges_single_version_min_open(self): + for inclusive_max1 in (True, False): + test_data = deepcopy(self.version_test_data) + expected_result = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 12), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 13), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 14), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.3)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.4)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.6)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.7)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.8)}), + ] + ) + + if not inclusive_max1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + expected_result.sort() + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, + remove, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_max_version1=8, + value_max_version1_inclusive=inclusive_max1, + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + f"\ninclusive_min1: {inclusive_max1}\n" + + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + f"\ninclusive_min1: {inclusive_max1}\n" + + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + # remove all elements which are bigger than a minimum version + def test_remove_parameter_value_pairs_ranges_single_version_max_open(self): + for inclusive_min1 in (True, False): + test_data = deepcopy(self.version_test_data) + expected_result = parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 10.2)}), + ] + ) + + if not inclusive_min1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + expected_result.sort() + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, + remove, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_min_version1=8, + value_min_version1_inclusive=inclusive_min1, + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + f"\ninclusive_min1: {inclusive_min1}\n" + + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + f"\ninclusive_min1: {inclusive_min1}\n" + + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + # remove all elements within a version range + def test_remove_parameter_value_pairs_ranges_single_version_in_range(self): + for inclusive_min1, inclusive_max1 in bool_map(2): + test_data = deepcopy(self.version_test_data) + expected_result = parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 14), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 10.2)}), + ] + ) + + if not inclusive_min1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + if not inclusive_max1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 13), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + expected_result.sort() + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, + remove, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_min_version1=8, + value_min_version1_inclusive=inclusive_min1, + value_max_version1=13, + value_max_version1_inclusive=inclusive_max1, + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + f"\ninclusive_min1: {inclusive_min1} - inclusive_max1: {inclusive_max1}\n" + + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + f"\ninclusive_min1: {inclusive_min1} - inclusive_max1: {inclusive_max1}\n" + + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + # remove all GCC 9 and newer (corner case GCC 8 ) and + # remove all NVCC 11.6 and older (corner case NVCC 11.7) + def test_remove_parameter_value_pairs_ranges_both_version_open(self): + for inclusive_min1, inclusive_max2 in bool_map(2): + test_data = deepcopy(self.version_test_data) + expected_result = parse_expected_val_pairs( + [ + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 10.2)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.8)}), + ] + ) + + if not inclusive_min1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + if not inclusive_max2: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.7)}), + ] + ) + + expected_result.sort() + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, + remove, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_min_version1=8, + value_min_version1_inclusive=inclusive_min1, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + value_max_version2="11.7", + value_max_version2_inclusive=inclusive_max2, + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + f"\ninclusive_min1: {inclusive_min1} - inclusive_max2: {inclusive_max2}\n" + + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + f"\ninclusive_min1: {inclusive_min1} - inclusive_max2: {inclusive_max2}\n" + + create_diff_parameter_value_pairs(remove, expected_remove), + ) + + def test_remove_parameter_value_pairs_ranges_both_version_in_range(self): + for inclusive_min1, inclusive_max1, inclusive_min2, inclusive_max2 in bool_map(4): + test_data = deepcopy(self.version_test_data) + expected_result = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({UBUNTU: (UBUNTU, "20.04"), CMAKE: (CMAKE, "3.19")}), + OD({BOOST: (BOOST, "1.81.1"), DEVICE_COMPILER: (GCC, 11)}), + OD({CMAKE: (CMAKE, "3.19"), UBUNTU: (UBUNTU, 3.19)}), + OD({DEVICE_COMPILER: (HIPCC, 6.2), HOST_COMPILER: (HIPCC, 6.2)}), + OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 14), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 11.5)}), + OD({HOST_COMPILER: (GCC, 4), DEVICE_COMPILER: (NVCC, 10.2)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.8)}), + ] + ) + + if not inclusive_min1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + if not inclusive_max1: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 13), DEVICE_COMPILER: (NVCC, 11.5)}), + ] + ) + + if not inclusive_min2: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.3)}), + ] + ) + + if not inclusive_max2: + expected_result += parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.7)}), + ] + ) + + expected_result.sort() + expected_remove = sorted(list(set(test_data) - set(expected_result))) + remove: List[ParameterValuePair] = [] + + remove_parameter_value_pairs_ranges( + test_data, + remove, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_min_version1=8, + value_min_version1_inclusive=inclusive_min1, + value_max_version1=13, + value_max_version1_inclusive=inclusive_max1, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + value_min_version2=11.3, + value_min_version2_inclusive=inclusive_min2, + value_max_version2=11.7, + value_max_version2_inclusive=inclusive_max2, + ) + + test_data.sort() + remove.sort() + + self.assertEqual( + test_data, + expected_result, + f"\ninclusive_min1: {inclusive_min1} - inclusive_max1: {inclusive_max1}\n" + f"inclusive_min2: {inclusive_min2} - inclusive_max2: {inclusive_max2}\n" + + create_diff_parameter_value_pairs(test_data, expected_result), + ) + self.assertEqual( + remove, + expected_remove, + f"\ninclusive_min1: {inclusive_min1} - inclusive_max1: {inclusive_max1}\n" + f"inclusive_min2: {inclusive_min2} - inclusive_max2: {inclusive_max2}\n" + + create_diff_parameter_value_pairs(remove, expected_remove), + ) diff --git a/tests/utils_test.py b/tests/utils_test.py index 229d51e..0494d48 100644 --- a/tests/utils_test.py +++ b/tests/utils_test.py @@ -62,7 +62,7 @@ def parse_expected_val_pairs( for param_val_pair in input_list: if len(param_val_pair) != 2: - raise RuntimeError("input_list needs to have two entries") + raise RuntimeError(f"{param_val_pair}\ninput_list needs to have two entries") it = iter(param_val_pair.items()) param1, param_val1 = next(it) From df2e244dc2045256c37973b2dba91c976d835aa7 Mon Sep 17 00:00:00 2001 From: Simeon Ehrig Date: Sat, 21 Sep 2024 13:36:54 +0200 Subject: [PATCH 2/6] port results.py from remove_parameter_value_pairs() to remove_parameter_value_pairs_ranges() - not complete yet --- src/bashi/results.py | 50 +++++++++++++++++++++++++------------------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/src/bashi/results.py b/src/bashi/results.py index bff2586..07a3ee9 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 ( + get_expected_parameter_value_pairs, + remove_parameter_value_pairs, + remove_parameter_value_pairs_ranges, + bi_filter, +) from bashi.globals import * # pylint: disable=wildcard-import,unused-wildcard-import from bashi.versions import ( COMPILERS, @@ -96,7 +101,7 @@ def _remove_nvcc_host_compiler( parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=HOST_COMPILER, @@ -555,15 +560,15 @@ def _remove_enabled_cuda_backend_for_icpx( removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ 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=compiler_type, value_name1=ICPX, - value_version1=ANY_VERSION, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2="==0.0.0", + value_min_version2=OFF, + value_min_version2_inclusive=False, ) @@ -576,15 +581,17 @@ def _remove_enabled_cuda_backend_for_enabled_sycl_backend( parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=ALPAKA_ACC_SYCL_ENABLE, value_name1=ALPAKA_ACC_SYCL_ENABLE, - value_version1=ON, + value_min_version1=ON, + value_max_version1=ON, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2="==0.0.0", + value_min_version2=OFF, + value_min_version2_inclusive=False, ) @@ -665,15 +672,15 @@ def _remove_device_compiler_gcc_clang_enabled_cuda_backend( removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ for compiler in (GCC, CLANG): - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=DEVICE_COMPILER, value_name1=compiler, - value_version1=ANY_VERSION, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2="==0.0.0", + value_min_version2=OFF, + value_min_version2_inclusive=False, ) @@ -767,17 +774,16 @@ def _remove_unsupported_gcc_versions_for_ubuntu2004( parameter_value_pairs (List[ParameterValuePair]): List of parameter-value pairs. """ for compiler_type in (HOST_COMPILER, DEVICE_COMPILER): - for gcc_version in range(1, 7): - remove_parameter_value_pairs( - parameter_value_pairs, - removed_parameter_value_pairs, - parameter1=compiler_type, - value_name1=GCC, - value_version1=gcc_version, - parameter2=UBUNTU, - value_name2=UBUNTU, - value_version2="<20.04", - ) + remove_parameter_value_pairs_ranges( + parameter_value_pairs, + removed_parameter_value_pairs, + parameter1=compiler_type, + value_name1=GCC, + value_max_version1=6, + parameter2=UBUNTU, + value_name2=UBUNTU, + value_min_version2="20.04", + ) def _remove_unsupported_cmake_versions_for_clangcuda( From 3e75a0f5ece756b6a30aefc6b938bc5b75c689d1 Mon Sep 17 00:00:00 2001 From: Simeon Ehrig Date: Mon, 23 Sep 2024 10:21:17 +0200 Subject: [PATCH 3/6] remove version range support from `remove_parameter_value_pairs()` --- src/bashi/utils.py | 204 ++-- tests/test_expected_parameter_value.py | 629 ++++++++++++ tests/test_expected_parameter_value_pairs.py | 986 ------------------- 3 files changed, 700 insertions(+), 1119 deletions(-) create mode 100644 tests/test_expected_parameter_value.py diff --git a/src/bashi/utils.py b/src/bashi/utils.py index 6dda369..16c993f 100644 --- a/src/bashi/utils.py +++ b/src/bashi/utils.py @@ -6,7 +6,7 @@ from typing import IO, Dict, List, Optional, Union, Callable import packaging.version -from packaging.specifiers import SpecifierSet, InvalidSpecifier +from packaging.specifiers import SpecifierSet from typeguard import typechecked from bashi.types import ( @@ -228,138 +228,6 @@ def bi_filter( parameter_value_pairs[:] = tmp_parameter_value_pairs -# pylint: disable=too-many-locals -@typechecked -def remove_parameter_value_pairs( # 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_version1: Union[int, float, str] = ANY_VERSION, - parameter2: Parameter = ANY_PARAM, - value_name2: ValueName = ANY_NAME, - value_version2: Union[int, float, str] = ANY_VERSION, - symmetric: bool = True, -) -> bool: - """Removes a parameter-value-pair from a list based on the specified search criteria. A - parameter-value pair must match all specified search criteria to be removed if none of the - criteria is `ANY_*`. If a criterion is `ANY_*`, it is ignored and it is always a match. - - Args: - parameter_value_pairs (List[ParameterValuePair]): list where parameter-value-pairs will be - removed - 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_version1 (Union[int, float, str], optional): Name of the first value-version. Either - as a single version or as a version range that can be parsed into a - `packaging.specifier.SpecifierSet`. If it is a version range, all versions that are not - within this range are removed. Defaults to ANY_VERSION. - parameter2 (Parameter, optional): Name of the second parameter. Defaults to ANY_PARAM. - value_name2 (ValueName, optional): Name of the second value-name. Defaults to ANY_NAME. - value_version2 (Union[int, float, str], optional): Name of the second value-name. Either as - a single version or as a version range that can be parsed into a - `packaging.specifier.SpecifierSet`. If it is a version range, all versions that are not - within this range are removed. Defaults to ANY_VERSION. - 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) - - def is_specifier_set(version: Union[int, float, str]) -> bool: - try: - SpecifierSet(str(version)) - return True - except InvalidSpecifier: - return False - - if ( - value_version1 != ANY_VERSION - and value_version2 != ANY_VERSION - and is_specifier_set(value_version1) - and is_specifier_set(value_version2) - ): - specifier_set_version1 = SpecifierSet(str(value_version1)) - specifier_set_version2 = SpecifierSet(str(value_version2)) - - filter_list.append( - lambda param_val: not ( - param_val.first.parameterValue.version in specifier_set_version1 - and param_val.second.parameterValue.version in specifier_set_version2 - ) - ) - - else: - if value_version1 != ANY_VERSION: - try: - specifier_set_version1 = SpecifierSet(str(value_version1)) - filter_list.append( - lambda param_val: not param_val.first.parameterValue.version - in specifier_set_version1 - ) - except InvalidSpecifier: - parsed_value_version1 = packaging.version.parse(str(value_version1)) - filter_list.append( - lambda param_val: param_val.first.parameterValue.version - == parsed_value_version1 - ) - - if value_version2 != ANY_VERSION: - try: - specifier_set_version2 = SpecifierSet(str(value_version2)) - filter_list.append( - lambda param_val: not param_val.second.parameterValue.version - in specifier_set_version2 - ) - except InvalidSpecifier: - parsed_value_version2 = packaging.version.parse(str(value_version2)) - filter_list.append( - lambda param_val: param_val.second.parameterValue.version - == parsed_value_version2 - ) - - 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( - parameter_value_pairs, - removed_parameter_value_pairs, - parameter2, - value_name2, - value_version2, - parameter1, - value_name1, - value_version1, - symmetric=False, - ) - - return len_before != len(parameter_value_pairs) - - @typechecked def check_parameter_value_pair_in_combination_list( combination_list: CombinationList, @@ -533,6 +401,7 @@ def _create_version_range( return min_range & max_range +# pylint: disable=too-many-locals @typechecked def remove_parameter_value_pairs_ranges( # pylint: disable=too-many-arguments parameter_value_pairs: List[ParameterValuePair], @@ -556,6 +425,10 @@ def remove_parameter_value_pairs_ranges( # pylint: disable=too-many-arguments 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”. + Use `remove_parameter_value_pairs()` if you want to remove a single version from the first + and/or second parameter value. If you want to remove a range of versions, use + `remove_parameter_value_pairs_ranges()`. + 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 @@ -664,3 +537,68 @@ def filter_func(param_value_pair: ParameterValuePair) -> bool: ) return len_before != len(parameter_value_pairs) + + +# pylint: disable=too-many-locals +@typechecked +def remove_parameter_value_pairs( # 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_version1: Union[int, float, str] = ANY_VERSION, + parameter2: Parameter = ANY_PARAM, + value_name2: ValueName = ANY_NAME, + value_version2: Union[int, float, str] = ANY_VERSION, + symmetric: bool = True, +) -> bool: + """Removes a parameter-value-pair from a list based on the specified search criteria. A + parameter-value pair must match all specified search criteria to be removed if none of the + criteria is `ANY_*`. If a criterion is `ANY_*`, it is ignored and it is always a match. + + Use `remove_parameter_value_pairs()` if you want to remove a single version from the first + and/or second parameter value. If you want to remove a range of versions, use + `remove_parameter_value_pairs_ranges()`. + + 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_version1 (Union[int, float, str], optional): Name of the first value-version. Needs to + be parsable to `Packaging.version.Version`. Defaults to ANY_VERSION. + parameter2 (Parameter, optional): Name of the second parameter. Defaults to ANY_PARAM. + value_name2 (ValueName, optional): Name of the second value-name. Defaults to ANY_NAME. + value_version2 (Union[int, float, str], optional): Name of the second value-name. Needs to + be parsable to `Packaging.version.Version`. Defaults to ANY_VERSION. + 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. + """ + for v in (value_version1, value_version2): + if v != ANY_VERSION: + packaging.version.Version(str(v)) + + return remove_parameter_value_pairs_ranges( + parameter_value_pairs=parameter_value_pairs, + removed_parameter_value_pairs=removed_parameter_value_pairs, + parameter1=parameter1, + value_name1=value_name1, + value_min_version1=value_version1, + value_min_version1_inclusive=True, + value_max_version1=value_version1, + value_max_version1_inclusive=True, + parameter2=parameter2, + value_name2=value_name2, + value_min_version2=value_version2, + value_min_version2_inclusive=True, + value_max_version2=value_version2, + value_max_version2_inclusive=True, + symmetric=symmetric, + ) diff --git a/tests/test_expected_parameter_value.py b/tests/test_expected_parameter_value.py new file mode 100644 index 0000000..bc8b355 --- /dev/null +++ b/tests/test_expected_parameter_value.py @@ -0,0 +1,629 @@ +# pylint: disable=missing-docstring +import unittest +from collections import OrderedDict as OD +import copy + +from utils_test import parse_expected_val_pairs, create_diff_parameter_value_pairs +from bashi.types import ( + ParameterValuePair, +) +from bashi.globals import * # pylint: disable=wildcard-import,unused-wildcard-import +from bashi.utils import remove_parameter_value_pairs + + +class TestRemoveExpectedParameterValuePairs(unittest.TestCase): + def test_remove_parameter_value_pair(self): + test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + ] + ) + original_length = len(test_param_value_pairs) + + t1_no_remove = copy.deepcopy(test_param_value_pairs) + t1_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + ] + ) + ) + t1_unexpected: List[ParameterValuePair] = sorted(list(set(t1_no_remove) - set(t1_expected))) + + t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertFalse( + remove_parameter_value_pairs( + t1_no_remove, + t1_unexpected_test_param_value_pairs, + HOST_COMPILER, + GCC, + 9, + DEVICE_COMPILER, + NVCC, + 11.2, + ) + ) + + t1_no_remove.sort() + t1_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t1_no_remove, t1_expected, create_diff_parameter_value_pairs(t1_no_remove, t1_expected) + ) + self.assertEqual(len(t1_no_remove), original_length) + self.assertEqual( + t1_unexpected_test_param_value_pairs, + t1_unexpected, + create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), + ) + + t2_remove_single_entry = copy.deepcopy(t1_no_remove) + t2_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + ] + ) + ) + t2_unexpected: List[ParameterValuePair] = sorted( + list(set(t2_remove_single_entry) - set(t2_expected)) + ) + + t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t2_remove_single_entry, + t2_unexpected_test_param_value_pairs, + HOST_COMPILER, + GCC, + 10, + DEVICE_COMPILER, + NVCC, + 12.0, + ) + ) + + t2_remove_single_entry.sort() + t2_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t2_remove_single_entry, + t2_expected, + create_diff_parameter_value_pairs(t2_remove_single_entry, t2_expected), + ) + self.assertEqual(len(t2_remove_single_entry), original_length - 1) + self.assertEqual( + t2_unexpected_test_param_value_pairs, + t2_unexpected, + create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), + ) + + t3_remove_another_entry = copy.deepcopy(t2_remove_single_entry) + t3_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + ] + ) + ) + t3_unexpected: List[ParameterValuePair] = sorted( + list(set(t3_remove_another_entry) - set(t3_expected)) + ) + + t3_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t3_remove_another_entry, + t3_unexpected_test_param_value_pairs, + CMAKE, + CMAKE, + 3.23, + BOOST, + BOOST, + 1.83, + ) + ) + + t3_remove_another_entry.sort() + t3_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t3_remove_another_entry, + t3_expected, + create_diff_parameter_value_pairs(t3_remove_another_entry, t3_expected), + ) + self.assertEqual(len(t3_remove_another_entry), original_length - 2) + self.assertEqual( + t3_unexpected_test_param_value_pairs, + t3_unexpected, + create_diff_parameter_value_pairs(t3_unexpected_test_param_value_pairs, t3_unexpected), + ) + + def test_all_white_card(self): + test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + ] + ) + len_before = len(test_param_value_pairs) + + unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + test_param_value_pairs, + unexpected_test_param_value_pairs, + parameter1=ANY_PARAM, + value_name1=ANY_NAME, + value_version1=ANY_VERSION, + parameter2=ANY_PARAM, + value_name2=ANY_NAME, + value_version2=ANY_VERSION, + ) + ) + + self.assertEqual(len(test_param_value_pairs), 0) + self.assertEqual(len(unexpected_test_param_value_pairs), len_before) + + def test_single_white_card(self): + test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + ] + ) + test_original_len = len(test_param_value_pairs) + + t1_any_version1_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t1_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + ] + ) + ) + t1_unexpected: List[ParameterValuePair] = sorted( + list(set(t1_any_version1_param_value_pairs) - set(t1_expected)) + ) + + t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t1_any_version1_param_value_pairs, + t1_unexpected_test_param_value_pairs, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_version1=ANY_VERSION, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + value_version2=12.0, + ) + ) + t1_any_version1_param_value_pairs.sort() + t1_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t1_any_version1_param_value_pairs, + t1_expected, + create_diff_parameter_value_pairs(t1_any_version1_param_value_pairs, t1_expected), + ) + self.assertEqual(len(t1_any_version1_param_value_pairs), test_original_len - 2) + self.assertEqual( + t1_unexpected_test_param_value_pairs, + t1_unexpected, + create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), + ) + + t2_any_name1_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t2_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), + ] + ) + ) + t2_unexpected: List[ParameterValuePair] = sorted( + list(set(t2_any_name1_param_value_pairs) - set(t2_expected)) + ) + + t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t2_any_name1_param_value_pairs, + t2_unexpected_test_param_value_pairs, + parameter1=HOST_COMPILER, + value_name1=ANY_NAME, + value_version1=10, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + value_version2=12.0, + ) + ) + + t2_any_name1_param_value_pairs.sort() + t2_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t2_any_name1_param_value_pairs, + t2_expected, + create_diff_parameter_value_pairs(t2_any_name1_param_value_pairs, t2_expected), + ) + self.assertEqual(len(t2_any_name1_param_value_pairs), test_original_len - 2) + self.assertEqual( + t2_unexpected_test_param_value_pairs, + t2_unexpected, + create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), + ) + + def test_white_card_multi_parameter(self): + t1_any_parameter_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({BOOST: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), + OD({HOST_COMPILER: (CLANG, 17), DEVICE_COMPILER: (CLANG, 16)}), + OD({CMAKE: (GCC, 10), UBUNTU: (NVCC, 11.2)}), + ] + ) + test_original_len = len(t1_any_parameter_param_value_pairs) + + t1_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), + OD({HOST_COMPILER: (CLANG, 17), DEVICE_COMPILER: (CLANG, 16)}), + ] + ) + ) + t1_unexpected: List[ParameterValuePair] = sorted( + list(set(t1_any_parameter_param_value_pairs) - set(t1_expected)) + ) + + t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t1_any_parameter_param_value_pairs, + t1_unexpected_test_param_value_pairs, + parameter1=ANY_PARAM, + value_name1=GCC, + value_version1=10, + parameter2=ANY_PARAM, + value_name2=NVCC, + value_version2=11.2, + ) + ) + + t1_any_parameter_param_value_pairs.sort() + t1_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t1_any_parameter_param_value_pairs, + t1_expected, + create_diff_parameter_value_pairs(t1_any_parameter_param_value_pairs, t1_expected), + ) + self.assertEqual(len(t1_any_parameter_param_value_pairs), test_original_len - 3) + self.assertEqual( + t1_unexpected_test_param_value_pairs, + t1_unexpected, + create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), + ) + + def test_remove_all_gcc_host(self): + test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), + OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + ] + ) + test_original_len = len(test_param_value_pairs) + t_expected = sorted( + parse_expected_val_pairs( + [ + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), + OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + ] + ) + ) + t1_unexpected: List[ParameterValuePair] = sorted( + list(set(test_param_value_pairs) - set(t_expected)) + ) + + unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + test_param_value_pairs, + unexpected_test_param_value_pairs, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_version1=ANY_VERSION, + ) + ) + + test_param_value_pairs.sort() + unexpected_test_param_value_pairs.sort() + + self.assertEqual( + test_param_value_pairs, + t_expected, + create_diff_parameter_value_pairs(test_param_value_pairs, t_expected), + ) + self.assertEqual(len(test_param_value_pairs), test_original_len - 5) + self.assertEqual( + unexpected_test_param_value_pairs, + t1_unexpected, + create_diff_parameter_value_pairs(unexpected_test_param_value_pairs, t1_unexpected), + ) + + def test_symmetric(self): + test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), + OD({DEVICE_COMPILER: (NVCC, 12.0), HOST_COMPILER: (GCC, 10)}), + OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), + ] + ) + test_original_len = len(test_param_value_pairs) + t1_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), + OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), + ] + ) + ) + t1_single_hit_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t1_unexpected: List[ParameterValuePair] = sorted( + list(set(t1_single_hit_symmetric_param_value_pairs) - set(t1_expected)) + ) + + t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t1_single_hit_symmetric_param_value_pairs, + t1_unexpected_test_param_value_pairs, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_version1=10, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + value_version2=12.0, + ) + ) + + t1_single_hit_symmetric_param_value_pairs.sort() + t1_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t1_single_hit_symmetric_param_value_pairs, + t1_expected, + create_diff_parameter_value_pairs( + t1_single_hit_symmetric_param_value_pairs, t1_expected + ), + ) + self.assertEqual(len(t1_single_hit_symmetric_param_value_pairs), test_original_len - 2) + self.assertEqual( + t1_unexpected_test_param_value_pairs, + t1_unexpected, + create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), + ) + + t2_single_hit_no_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t2_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), + OD({DEVICE_COMPILER: (NVCC, 12.0), HOST_COMPILER: (GCC, 10)}), + OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), + ] + ) + ) + t2_unexpected: List[ParameterValuePair] = sorted( + list(set(t2_single_hit_no_symmetric_param_value_pairs) - set(t2_expected)) + ) + + t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t2_single_hit_no_symmetric_param_value_pairs, + t2_unexpected_test_param_value_pairs, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_version1=10, + parameter2=DEVICE_COMPILER, + value_name2=NVCC, + value_version2=12.0, + symmetric=False, + ) + ) + + t2_single_hit_no_symmetric_param_value_pairs.sort() + t2_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t2_single_hit_no_symmetric_param_value_pairs, + t2_expected, + create_diff_parameter_value_pairs( + t2_single_hit_no_symmetric_param_value_pairs, t2_expected + ), + ) + self.assertEqual(len(t2_single_hit_no_symmetric_param_value_pairs), test_original_len - 1) + self.assertEqual( + t2_unexpected_test_param_value_pairs, + t2_unexpected, + create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), + ) + + t3_single_hit_no_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t3_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), + OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), + ] + ) + ) + t3_unexpected: List[ParameterValuePair] = sorted( + list(set(t3_single_hit_no_symmetric_param_value_pairs) - set(t3_expected)) + ) + + t3_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t3_single_hit_no_symmetric_param_value_pairs, + t3_unexpected_test_param_value_pairs, + parameter1=DEVICE_COMPILER, + value_name1=NVCC, + value_version1=12.0, + parameter2=HOST_COMPILER, + value_name2=GCC, + value_version2=10, + symmetric=False, + ) + ) + + t3_single_hit_no_symmetric_param_value_pairs.sort() + t3_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t3_single_hit_no_symmetric_param_value_pairs, + t3_expected, + create_diff_parameter_value_pairs( + t3_single_hit_no_symmetric_param_value_pairs, t3_expected + ), + ) + self.assertEqual(len(t3_single_hit_no_symmetric_param_value_pairs), test_original_len - 1) + self.assertEqual( + t3_unexpected_test_param_value_pairs, + t3_unexpected, + create_diff_parameter_value_pairs(t3_unexpected_test_param_value_pairs, t3_unexpected), + ) + + t4_multi_hit_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t4_expected = sorted( + parse_expected_val_pairs( + [ + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), + ] + ) + ) + t4_unexpected: List[ParameterValuePair] = sorted( + list(set(t4_multi_hit_symmetric_param_value_pairs) - set(t4_expected)) + ) + + t4_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + self.assertTrue( + remove_parameter_value_pairs( + t4_multi_hit_symmetric_param_value_pairs, + t4_unexpected_test_param_value_pairs, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_version1=ANY_VERSION, + ) + ) + + t4_multi_hit_symmetric_param_value_pairs.sort() + t4_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t4_multi_hit_symmetric_param_value_pairs, + t4_expected, + create_diff_parameter_value_pairs( + t4_multi_hit_symmetric_param_value_pairs, t4_expected + ), + ) + self.assertEqual(len(t4_multi_hit_symmetric_param_value_pairs), test_original_len - 4) + self.assertEqual( + t4_unexpected_test_param_value_pairs, + t4_unexpected, + create_diff_parameter_value_pairs(t4_unexpected_test_param_value_pairs, t4_unexpected), + ) + + t5_multi_hit_no_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) + t5_expected = sorted( + parse_expected_val_pairs( + [ + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), + OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), + ] + ) + ) + t5_unexpected: List[ParameterValuePair] = sorted( + list(set(t5_multi_hit_no_symmetric_param_value_pairs) - set(t5_expected)) + ) + + t5_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] + + self.assertTrue( + remove_parameter_value_pairs( + t5_multi_hit_no_symmetric_param_value_pairs, + t5_unexpected_test_param_value_pairs, + parameter2=HOST_COMPILER, + value_name2=GCC, + value_version2=ANY_VERSION, + symmetric=False, + ) + ) + + t5_multi_hit_no_symmetric_param_value_pairs.sort() + t5_unexpected_test_param_value_pairs.sort() + + self.assertEqual( + t5_multi_hit_no_symmetric_param_value_pairs, + t5_expected, + create_diff_parameter_value_pairs( + t5_multi_hit_no_symmetric_param_value_pairs, t5_expected + ), + ) + self.assertEqual(len(t5_multi_hit_no_symmetric_param_value_pairs), test_original_len - 2) + self.assertEqual( + t5_unexpected_test_param_value_pairs, + t5_unexpected, + create_diff_parameter_value_pairs(t5_unexpected_test_param_value_pairs, t5_unexpected), + ) diff --git a/tests/test_expected_parameter_value_pairs.py b/tests/test_expected_parameter_value_pairs.py index 667abdc..ec34942 100644 --- a/tests/test_expected_parameter_value_pairs.py +++ b/tests/test_expected_parameter_value_pairs.py @@ -1,6 +1,5 @@ # pylint: disable=missing-docstring import unittest -import copy from typing import List, Dict from collections import OrderedDict as OD import io @@ -11,7 +10,6 @@ parse_param_val, parse_param_vals, parse_expected_val_pairs, - create_diff_parameter_value_pairs, ) from covertable import make from bashi.types import ( @@ -27,7 +25,6 @@ get_expected_parameter_value_pairs, check_parameter_value_pair_in_combination_list, check_unexpected_parameter_value_pair_in_combination_list, - remove_parameter_value_pairs, create_parameter_value_pair, ) @@ -614,986 +611,3 @@ def test_unrestricted_covertable_generator(self): self.assertTrue( check_parameter_value_pair_in_combination_list(comb_list, self.expected_param_val_pairs) ) - - -class TestRemoveExpectedParameterValuePairs(unittest.TestCase): - def test_remove_parameter_value_pair(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - original_length = len(test_param_value_pairs) - - t1_no_remove = copy.deepcopy(test_param_value_pairs) - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted(list(set(t1_no_remove) - set(t1_expected))) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertFalse( - remove_parameter_value_pairs( - t1_no_remove, - t1_unexpected_test_param_value_pairs, - HOST_COMPILER, - GCC, - 9, - DEVICE_COMPILER, - NVCC, - 11.2, - ) - ) - - t1_no_remove.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_no_remove, t1_expected, create_diff_parameter_value_pairs(t1_no_remove, t1_expected) - ) - self.assertEqual(len(t1_no_remove), original_length) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - t2_remove_single_entry = copy.deepcopy(t1_no_remove) - t2_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t2_unexpected: List[ParameterValuePair] = sorted( - list(set(t2_remove_single_entry) - set(t2_expected)) - ) - - t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t2_remove_single_entry, - t2_unexpected_test_param_value_pairs, - HOST_COMPILER, - GCC, - 10, - DEVICE_COMPILER, - NVCC, - 12.0, - ) - ) - - t2_remove_single_entry.sort() - t2_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t2_remove_single_entry, - t2_expected, - create_diff_parameter_value_pairs(t2_remove_single_entry, t2_expected), - ) - self.assertEqual(len(t2_remove_single_entry), original_length - 1) - self.assertEqual( - t2_unexpected_test_param_value_pairs, - t2_unexpected, - create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), - ) - - t3_remove_another_entry = copy.deepcopy(t2_remove_single_entry) - t3_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - ] - ) - ) - t3_unexpected: List[ParameterValuePair] = sorted( - list(set(t3_remove_another_entry) - set(t3_expected)) - ) - - t3_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t3_remove_another_entry, - t3_unexpected_test_param_value_pairs, - CMAKE, - CMAKE, - 3.23, - BOOST, - BOOST, - 1.83, - ) - ) - - t3_remove_another_entry.sort() - t3_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t3_remove_another_entry, - t3_expected, - create_diff_parameter_value_pairs(t3_remove_another_entry, t3_expected), - ) - self.assertEqual(len(t3_remove_another_entry), original_length - 2) - self.assertEqual( - t3_unexpected_test_param_value_pairs, - t3_unexpected, - create_diff_parameter_value_pairs(t3_unexpected_test_param_value_pairs, t3_unexpected), - ) - - def test_all_white_card(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - len_before = len(test_param_value_pairs) - - unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - test_param_value_pairs, - unexpected_test_param_value_pairs, - parameter1=ANY_PARAM, - value_name1=ANY_NAME, - value_version1=ANY_VERSION, - parameter2=ANY_PARAM, - value_name2=ANY_NAME, - value_version2=ANY_VERSION, - ) - ) - - self.assertEqual(len(test_param_value_pairs), 0) - self.assertEqual(len(unexpected_test_param_value_pairs), len_before) - - def test_single_white_card(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - ] - ) - test_original_len = len(test_param_value_pairs) - - t1_any_version1_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_any_version1_param_value_pairs) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t1_any_version1_param_value_pairs, - t1_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=ANY_VERSION, - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=12.0, - ) - ) - t1_any_version1_param_value_pairs.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_any_version1_param_value_pairs, - t1_expected, - create_diff_parameter_value_pairs(t1_any_version1_param_value_pairs, t1_expected), - ) - self.assertEqual(len(t1_any_version1_param_value_pairs), test_original_len - 2) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - t2_any_name1_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t2_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t2_unexpected: List[ParameterValuePair] = sorted( - list(set(t2_any_name1_param_value_pairs) - set(t2_expected)) - ) - - t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t2_any_name1_param_value_pairs, - t2_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=ANY_NAME, - value_version1=10, - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=12.0, - ) - ) - - t2_any_name1_param_value_pairs.sort() - t2_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t2_any_name1_param_value_pairs, - t2_expected, - create_diff_parameter_value_pairs(t2_any_name1_param_value_pairs, t2_expected), - ) - self.assertEqual(len(t2_any_name1_param_value_pairs), test_original_len - 2) - self.assertEqual( - t2_unexpected_test_param_value_pairs, - t2_unexpected, - create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), - ) - - def test_white_card_multi_parameter(self): - t1_any_parameter_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({BOOST: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), - OD({HOST_COMPILER: (CLANG, 17), DEVICE_COMPILER: (CLANG, 16)}), - OD({CMAKE: (GCC, 10), UBUNTU: (NVCC, 11.2)}), - ] - ) - test_original_len = len(t1_any_parameter_param_value_pairs) - - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), - OD({HOST_COMPILER: (CLANG, 17), DEVICE_COMPILER: (CLANG, 16)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_any_parameter_param_value_pairs) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t1_any_parameter_param_value_pairs, - t1_unexpected_test_param_value_pairs, - parameter1=ANY_PARAM, - value_name1=GCC, - value_version1=10, - parameter2=ANY_PARAM, - value_name2=NVCC, - value_version2=11.2, - ) - ) - - t1_any_parameter_param_value_pairs.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_any_parameter_param_value_pairs, - t1_expected, - create_diff_parameter_value_pairs(t1_any_parameter_param_value_pairs, t1_expected), - ) - self.assertEqual(len(t1_any_parameter_param_value_pairs), test_original_len - 3) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - def test_remove_all_gcc_host(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (CLANG, 17)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (GCC, 17)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - ] - ) - test_original_len = len(test_param_value_pairs) - t_expected = sorted( - parse_expected_val_pairs( - [ - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), BOOST: (BOOST, 1.83)}), - OD({HOST_COMPILER: (CLANG, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(test_param_value_pairs) - set(t_expected)) - ) - - unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - test_param_value_pairs, - unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=ANY_VERSION, - ) - ) - - test_param_value_pairs.sort() - unexpected_test_param_value_pairs.sort() - - self.assertEqual( - test_param_value_pairs, - t_expected, - create_diff_parameter_value_pairs(test_param_value_pairs, t_expected), - ) - self.assertEqual(len(test_param_value_pairs), test_original_len - 5) - self.assertEqual( - unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(unexpected_test_param_value_pairs, t1_unexpected), - ) - - def test_symmetric(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), - OD({DEVICE_COMPILER: (NVCC, 12.0), HOST_COMPILER: (GCC, 10)}), - OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), - ] - ) - test_original_len = len(test_param_value_pairs) - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), - OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), - ] - ) - ) - t1_single_hit_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_single_hit_symmetric_param_value_pairs) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t1_single_hit_symmetric_param_value_pairs, - t1_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=10, - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=12.0, - ) - ) - - t1_single_hit_symmetric_param_value_pairs.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_single_hit_symmetric_param_value_pairs, - t1_expected, - create_diff_parameter_value_pairs( - t1_single_hit_symmetric_param_value_pairs, t1_expected - ), - ) - self.assertEqual(len(t1_single_hit_symmetric_param_value_pairs), test_original_len - 2) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - t2_single_hit_no_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t2_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), - OD({DEVICE_COMPILER: (NVCC, 12.0), HOST_COMPILER: (GCC, 10)}), - OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), - ] - ) - ) - t2_unexpected: List[ParameterValuePair] = sorted( - list(set(t2_single_hit_no_symmetric_param_value_pairs) - set(t2_expected)) - ) - - t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t2_single_hit_no_symmetric_param_value_pairs, - t2_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=10, - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=12.0, - symmetric=False, - ) - ) - - t2_single_hit_no_symmetric_param_value_pairs.sort() - t2_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t2_single_hit_no_symmetric_param_value_pairs, - t2_expected, - create_diff_parameter_value_pairs( - t2_single_hit_no_symmetric_param_value_pairs, t2_expected - ), - ) - self.assertEqual(len(t2_single_hit_no_symmetric_param_value_pairs), test_original_len - 1) - self.assertEqual( - t2_unexpected_test_param_value_pairs, - t2_unexpected, - create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), - ) - - t3_single_hit_no_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t3_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({DEVICE_COMPILER: (NVCC, 11.2), HOST_COMPILER: (GCC, 10)}), - OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), - ] - ) - ) - t3_unexpected: List[ParameterValuePair] = sorted( - list(set(t3_single_hit_no_symmetric_param_value_pairs) - set(t3_expected)) - ) - - t3_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t3_single_hit_no_symmetric_param_value_pairs, - t3_unexpected_test_param_value_pairs, - parameter1=DEVICE_COMPILER, - value_name1=NVCC, - value_version1=12.0, - parameter2=HOST_COMPILER, - value_name2=GCC, - value_version2=10, - symmetric=False, - ) - ) - - t3_single_hit_no_symmetric_param_value_pairs.sort() - t3_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t3_single_hit_no_symmetric_param_value_pairs, - t3_expected, - create_diff_parameter_value_pairs( - t3_single_hit_no_symmetric_param_value_pairs, t3_expected - ), - ) - self.assertEqual(len(t3_single_hit_no_symmetric_param_value_pairs), test_original_len - 1) - self.assertEqual( - t3_unexpected_test_param_value_pairs, - t3_unexpected, - create_diff_parameter_value_pairs(t3_unexpected_test_param_value_pairs, t3_unexpected), - ) - - t4_multi_hit_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t4_expected = sorted( - parse_expected_val_pairs( - [ - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), - ] - ) - ) - t4_unexpected: List[ParameterValuePair] = sorted( - list(set(t4_multi_hit_symmetric_param_value_pairs) - set(t4_expected)) - ) - - t4_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t4_multi_hit_symmetric_param_value_pairs, - t4_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=ANY_VERSION, - ) - ) - - t4_multi_hit_symmetric_param_value_pairs.sort() - t4_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t4_multi_hit_symmetric_param_value_pairs, - t4_expected, - create_diff_parameter_value_pairs( - t4_multi_hit_symmetric_param_value_pairs, t4_expected - ), - ) - self.assertEqual(len(t4_multi_hit_symmetric_param_value_pairs), test_original_len - 4) - self.assertEqual( - t4_unexpected_test_param_value_pairs, - t4_unexpected, - create_diff_parameter_value_pairs(t4_unexpected_test_param_value_pairs, t4_unexpected), - ) - - t5_multi_hit_no_symmetric_param_value_pairs = copy.deepcopy(test_param_value_pairs) - t5_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - OD({BOOST: (BOOST, 1.83), CMAKE: (CMAKE, 3.23)}), - ] - ) - ) - t5_unexpected: List[ParameterValuePair] = sorted( - list(set(t5_multi_hit_no_symmetric_param_value_pairs) - set(t5_expected)) - ) - - t5_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - - self.assertTrue( - remove_parameter_value_pairs( - t5_multi_hit_no_symmetric_param_value_pairs, - t5_unexpected_test_param_value_pairs, - parameter2=HOST_COMPILER, - value_name2=GCC, - value_version2=ANY_VERSION, - symmetric=False, - ) - ) - - t5_multi_hit_no_symmetric_param_value_pairs.sort() - t5_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t5_multi_hit_no_symmetric_param_value_pairs, - t5_expected, - create_diff_parameter_value_pairs( - t5_multi_hit_no_symmetric_param_value_pairs, t5_expected - ), - ) - self.assertEqual(len(t5_multi_hit_no_symmetric_param_value_pairs), test_original_len - 2) - self.assertEqual( - t5_unexpected_test_param_value_pairs, - t5_unexpected, - create_diff_parameter_value_pairs(t5_unexpected_test_param_value_pairs, t5_unexpected), - ) - - def test_single_specifier_set(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.0)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.1)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - test_original_len = len(test_param_value_pairs) - - t1_remove_cuda11 = copy.deepcopy(test_param_value_pairs) - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_remove_cuda11) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t1_remove_cuda11, - t1_unexpected_test_param_value_pairs, - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=">=12", - ) - ) - t1_remove_cuda11.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_remove_cuda11, - t1_expected, - create_diff_parameter_value_pairs(t1_remove_cuda11, t1_expected), - ) - self.assertEqual(len(t1_remove_cuda11), test_original_len - 9) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - t2_cuda113_to_cuda122_ignore_cuda116 = copy.deepcopy(test_param_value_pairs) - t2_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t2_unexpected: List[ParameterValuePair] = sorted( - list(set(t2_cuda113_to_cuda122_ignore_cuda116) - set(t2_expected)) - ) - - t2_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t2_cuda113_to_cuda122_ignore_cuda116, - t2_unexpected_test_param_value_pairs, - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=">=11.3,<12.3,!=11.6", - ) - ) - - t2_cuda113_to_cuda122_ignore_cuda116.sort() - t2_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t2_cuda113_to_cuda122_ignore_cuda116, - t2_expected, - create_diff_parameter_value_pairs(t2_cuda113_to_cuda122_ignore_cuda116, t2_expected), - ) - self.assertEqual(len(t2_cuda113_to_cuda122_ignore_cuda116), test_original_len - 5) - self.assertEqual( - t2_unexpected_test_param_value_pairs, - t2_unexpected, - create_diff_parameter_value_pairs(t2_unexpected_test_param_value_pairs, t2_unexpected), - ) - - t3_gcc_8_and_9 = copy.deepcopy(test_param_value_pairs) - t3_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t3_unexpected: List[ParameterValuePair] = sorted( - list(set(t3_gcc_8_and_9) - set(t3_expected)) - ) - - t3_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t3_gcc_8_and_9, - t3_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=">=8,<=9", - ) - ) - - t3_gcc_8_and_9.sort() - t3_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t3_gcc_8_and_9, - t3_expected, - create_diff_parameter_value_pairs(t3_gcc_8_and_9, t3_expected), - ) - self.assertEqual(len(t3_gcc_8_and_9), test_original_len - 9) - self.assertEqual( - t3_unexpected_test_param_value_pairs, - t3_unexpected, - create_diff_parameter_value_pairs(t3_unexpected_test_param_value_pairs, t3_unexpected), - ) - - def test_multi_specifier_set(self): - t1_remove_specific_gcc_and_cuda: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.0)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.1)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - test_original_len = len(t1_remove_specific_gcc_and_cuda) - - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_remove_specific_gcc_and_cuda) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - - self.assertTrue( - remove_parameter_value_pairs( - t1_remove_specific_gcc_and_cuda, - t1_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=">=10", - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=">=11.3,<=12.2,!=11.6", - ) - ) - t1_remove_specific_gcc_and_cuda.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_remove_specific_gcc_and_cuda, - t1_expected, - create_diff_parameter_value_pairs(t1_remove_specific_gcc_and_cuda, t1_expected), - ) - self.assertEqual(len(t1_remove_specific_gcc_and_cuda), test_original_len - 8) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - def test_version_and_specifier_set(self): - test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.0)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.1)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - test_original_len = len(test_param_value_pairs) - - t1_remove_specific_gcc_and_cuda = copy.deepcopy(test_param_value_pairs) - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_remove_specific_gcc_and_cuda) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - self.assertTrue( - remove_parameter_value_pairs( - t1_remove_specific_gcc_and_cuda, - t1_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1="10", - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2=">=11.3,<=12.2,!=11.6", - ) - ) - t1_remove_specific_gcc_and_cuda.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_remove_specific_gcc_and_cuda, - t1_expected, - create_diff_parameter_value_pairs(t1_remove_specific_gcc_and_cuda, t1_expected), - ) - self.assertEqual(len(t1_remove_specific_gcc_and_cuda), test_original_len - 2) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) - - def test_specifier_set_and_version(self): - t1_remove_specific_gcc_and_cuda: List[ParameterValuePair] = parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.0)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.1)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - test_original_len = len(t1_remove_specific_gcc_and_cuda) - t1_expected = sorted( - parse_expected_val_pairs( - [ - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.0)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.1)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.2)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 11.3)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 11.4)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 11.5)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.6)}), - OD({HOST_COMPILER: (GCC, 8), DEVICE_COMPILER: (NVCC, 11.7)}), - OD({HOST_COMPILER: (GCC, 9), DEVICE_COMPILER: (NVCC, 11.8)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.0)}), - OD({HOST_COMPILER: (GCC, 11), DEVICE_COMPILER: (NVCC, 12.1)}), - OD({HOST_COMPILER: (GCC, 10), DEVICE_COMPILER: (NVCC, 12.2)}), - OD({HOST_COMPILER: (GCC, 7), DEVICE_COMPILER: (NVCC, 12.3)}), - OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), - ] - ) - ) - t1_unexpected: List[ParameterValuePair] = sorted( - list(set(t1_remove_specific_gcc_and_cuda) - set(t1_expected)) - ) - - t1_unexpected_test_param_value_pairs: List[ParameterValuePair] = [] - - self.assertTrue( - remove_parameter_value_pairs( - t1_remove_specific_gcc_and_cuda, - t1_unexpected_test_param_value_pairs, - parameter1=HOST_COMPILER, - value_name1=GCC, - value_version1=">=10", - parameter2=DEVICE_COMPILER, - value_name2=NVCC, - value_version2="11.3", - ) - ) - t1_remove_specific_gcc_and_cuda.sort() - t1_unexpected_test_param_value_pairs.sort() - - self.assertEqual( - t1_remove_specific_gcc_and_cuda, - t1_expected, - create_diff_parameter_value_pairs(t1_remove_specific_gcc_and_cuda, t1_expected), - ) - self.assertEqual(len(t1_remove_specific_gcc_and_cuda), test_original_len - 2) - self.assertEqual( - t1_unexpected_test_param_value_pairs, - t1_unexpected, - create_diff_parameter_value_pairs(t1_unexpected_test_param_value_pairs, t1_unexpected), - ) From d94b57f382dbc1f57f741a8fdcd991dce2e39c76 Mon Sep 17 00:00:00 2001 From: Simeon Ehrig Date: Mon, 23 Sep 2024 10:28:46 +0200 Subject: [PATCH 4/6] port `remove_parameter_value_pairs()` to `remove_parameter_value_pairs_ranges()` if version ranges are used --- src/bashi/results.py | 111 ++++++++++++++++++++++++++---------------- src/bashi/utils.py | 3 ++ tests/test_results.py | 87 +++++++++++++++++++++++++++++++++ 3 files changed, 159 insertions(+), 42 deletions(-) diff --git a/src/bashi/results.py b/src/bashi/results.py index 07a3ee9..a13700f 100644 --- a/src/bashi/results.py +++ b/src/bashi/results.py @@ -49,15 +49,8 @@ def get_expected_bashi_parameter_value_pairs( _remove_unsupported_compiler_for_hip_backend(param_val_pair_list, removed_param_val_pair_list) _remove_disabled_hip_backend_for_hipcc(param_val_pair_list, removed_param_val_pair_list) _remove_enabled_sycl_backend_for_hipcc(param_val_pair_list, removed_param_val_pair_list) - remove_parameter_value_pairs( - param_val_pair_list, - removed_param_val_pair_list, - parameter1=ALPAKA_ACC_GPU_HIP_ENABLE, - value_name1=ALPAKA_ACC_GPU_HIP_ENABLE, - value_version1=ON, - parameter2=ALPAKA_ACC_SYCL_ENABLE, - value_name2=ALPAKA_ACC_SYCL_ENABLE, - value_version2=ON, + _remove_enabled_hip_and_sycl_backend_at_same_time( + param_val_pair_list, removed_param_val_pair_list ) _remove_enabled_cuda_backend_for_hipcc(param_val_pair_list, removed_param_val_pair_list) _remove_enabled_cuda_backend_for_enabled_hip_backend( @@ -119,12 +112,12 @@ def _remove_unsupported_clang_cuda_version( removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ 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=compiler_type, value_name1=CLANG_CUDA, - value_version1=">13", + value_max_version1=13, ) @@ -139,7 +132,7 @@ def _remove_unsupported_nvcc_host_compiler( removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ for compiler_name in set(COMPILERS) - set([GCC, CLANG, NVCC]): - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=HOST_COMPILER, @@ -164,7 +157,7 @@ def _remove_different_compiler_names( for host_compiler_name in set(COMPILERS) - set([NVCC]): for device_compiler_name in set(COMPILERS) - set([NVCC]): if host_compiler_name != device_compiler_name: - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=HOST_COMPILER, @@ -243,6 +236,7 @@ def _remove_nvcc_unsupported_clang_versions( ) +# pylint: disable=too-many-positional-arguments def _remove_unsupported_nvcc_cuda_host_compiler_versions( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], @@ -253,6 +247,7 @@ def _remove_unsupported_nvcc_cuda_host_compiler_versions( ): # pylint: disable=too-few-public-methods # pylint: disable=too-many-arguments + # pylint: disable=too-many-positional-arguments class _FilterFunctor: def __init__( self, @@ -359,15 +354,15 @@ def _remove_specific_nvcc_clang_combinations( parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=HOST_COMPILER, value_name1=CLANG, - value_version1=ANY_VERSION, parameter2=DEVICE_COMPILER, value_name2=NVCC, - value_version2="!=11.3,!=11.4,!=11.5", + value_min_version2="11.3", + value_max_version2="11.5", ) @@ -439,25 +434,46 @@ def _remove_enabled_sycl_backend_for_hipcc( ) +def _remove_enabled_hip_and_sycl_backend_at_same_time( + parameter_value_pairs: List[ParameterValuePair], + removed_parameter_value_pairs: List[ParameterValuePair], +): + """Remove all pairs, where the HIP and the sycl backend are enabled at the same time. + + parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list + removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs + """ + remove_parameter_value_pairs( + parameter_value_pairs, + removed_parameter_value_pairs, + parameter1=ALPAKA_ACC_GPU_HIP_ENABLE, + value_name1=ALPAKA_ACC_GPU_HIP_ENABLE, + value_version1=ON, + parameter2=ALPAKA_ACC_SYCL_ENABLE, + value_name2=ALPAKA_ACC_SYCL_ENABLE, + value_version2=ON, + ) + + def _remove_enabled_cuda_backend_for_hipcc( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hipcc is the compiler and the sycl backend is enabled. + """Remove all pairs, where the hipcc is the compiler and the cuda backend is enabled. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ 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=compiler_type, value_name1=HIPCC, - value_version1=ANY_VERSION, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2="==0.0.0", + value_min_version2=OFF, + value_min_version2_inclusive=False, ) @@ -465,20 +481,22 @@ def _remove_enabled_cuda_backend_for_enabled_hip_backend( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hipcc is the compiler and the sycl backend is enabled. + """Remove all pairs, where the HIP and the CUDA backend is enabled at the same time. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=ALPAKA_ACC_GPU_HIP_ENABLE, value_name1=ALPAKA_ACC_GPU_HIP_ENABLE, - value_version1=ON, + value_min_version1=OFF, + value_min_version1_inclusive=False, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2="==0.0.0", + value_min_version2=OFF, + value_min_version2_inclusive=False, ) @@ -486,7 +504,7 @@ def _remove_unsupported_compiler_for_sycl_backend( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hip backend is enabled and the compiler is not hipcc. + """Remove all pairs, where the compiler does not support the SYCL backend. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs @@ -510,7 +528,7 @@ def _remove_disabled_sycl_backend_for_icpx( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hipcc is the compiler and the hip backend is disabled. + """Remove all pairs, where the ICPX is the compiler and the SYCL backend is disabled. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs @@ -532,7 +550,7 @@ def _remove_enabled_hip_backend_for_icpx( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hipcc is the compiler and the sycl backend is enabled. + """Remove all pairs, where ICPX is the compiler and the HIP backend is enabled. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs @@ -554,7 +572,7 @@ def _remove_enabled_cuda_backend_for_icpx( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hipcc is the compiler and the sycl backend is enabled. + """Remove all pairs, where ICPX is the compiler and the CUDA backend is enabled. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs @@ -576,7 +594,7 @@ def _remove_enabled_cuda_backend_for_enabled_sycl_backend( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): - """Remove all pairs, where the hipcc is the compiler and the sycl backend is enabled. + """Remove all pairs, where the SYCL and the CUDA backend is enabled at the same time. parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs @@ -693,15 +711,15 @@ def _remove_specific_cuda_clang_combinations( parameter_value_pairs (List[ParameterValuePair]): parameter-value-pair list removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( parameter_value_pairs, removed_parameter_value_pairs, parameter1=HOST_COMPILER, value_name1=CLANG, - value_version1=ANY_VERSION, parameter2=ALPAKA_ACC_GPU_CUDA_ENABLE, value_name2=ALPAKA_ACC_GPU_CUDA_ENABLE, - value_version2="!=11.3,!=11.4,!=11.5", + value_min_version2=11.3, + value_max_version2=11.5, ) @@ -771,7 +789,9 @@ def _remove_unsupported_gcc_versions_for_ubuntu2004( """Remove pairs where GCC version 6 and older is used with Ubuntu 20.04 or newer. Args: - parameter_value_pairs (List[ParameterValuePair]): List of parameter-value pairs. + + parameter_value_pairs (List[ParameterValuePair]): List of parameter-value pairs. + removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs """ for compiler_type in (HOST_COMPILER, DEVICE_COMPILER): remove_parameter_value_pairs_ranges( @@ -790,16 +810,22 @@ def _remove_unsupported_cmake_versions_for_clangcuda( parameter_value_pairs: List[ParameterValuePair], removed_parameter_value_pairs: List[ParameterValuePair], ): + """Remove CMake 3.18 if Clang-CUDA is the host or device compiler. + + Args: + + parameter_value_pairs (List[ParameterValuePair]): List of parameter-value pairs. + removed_parameter_value_pairs (List[ParameterValuePair): list with removed parameter-value-pairs + """ 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=compiler_type, value_name1=CLANG_CUDA, - value_version1=ANY_VERSION, parameter2=CMAKE, value_name2=CMAKE, - value_version2=">3.18", + value_max_version2="3.18", ) @@ -812,24 +838,25 @@ def _remove_all_rocm_images_older_than_ubuntu2004_based( Args: parameter_value_pairs (List[ParameterValuePair]): List of parameter-value pairs. """ - 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_max_version1="20.04", + value_max_version1_inclusive=False, parameter2=ALPAKA_ACC_GPU_HIP_ENABLE, value_name2=ALPAKA_ACC_GPU_HIP_ENABLE, - value_version2=ON, + value_min_version2=ON, ) 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_max_version1="20.04", + value_max_version1_inclusive=False, parameter2=compiler_type, value_name2=HIPCC, - value_version2=ANY_VERSION, ) diff --git a/src/bashi/utils.py b/src/bashi/utils.py index 16c993f..2f3bb0e 100644 --- a/src/bashi/utils.py +++ b/src/bashi/utils.py @@ -98,6 +98,7 @@ def __call__(self, row: List[ParameterValue]) -> bool: return self.filter_func(ordered_row) +# pylint: disable=too-many-positional-arguments @typechecked def create_parameter_value_pair( # pylint: disable=too-many-arguments parameter1: str, @@ -402,6 +403,7 @@ def _create_version_range( # pylint: disable=too-many-locals +# pylint: disable=too-many-positional-arguments @typechecked def remove_parameter_value_pairs_ranges( # pylint: disable=too-many-arguments parameter_value_pairs: List[ParameterValuePair], @@ -540,6 +542,7 @@ def filter_func(param_value_pair: ParameterValuePair) -> bool: # pylint: disable=too-many-locals +# pylint: disable=too-many-positional-arguments @typechecked def remove_parameter_value_pairs( # pylint: disable=too-many-arguments parameter_value_pairs: List[ParameterValuePair], diff --git a/tests/test_results.py b/tests/test_results.py index 4702fa8..b85abcd 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -29,6 +29,7 @@ _remove_unsupported_compiler_for_hip_backend, _remove_disabled_hip_backend_for_hipcc, _remove_enabled_sycl_backend_for_hipcc, + _remove_enabled_hip_and_sycl_backend_at_same_time, _remove_enabled_cuda_backend_for_hipcc, _remove_enabled_cuda_backend_for_enabled_hip_backend, _remove_unsupported_compiler_for_sycl_backend, @@ -1072,6 +1073,92 @@ def test_remove_enabled_sycl_backend_for_hipcc(self): self, ) + def test_remove_enabled_hip_and_sycl_backend_at_same_time(self): + test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( + [ + OD( + { + HOST_COMPILER: (CLANG_CUDA, 16), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, ON), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, ON), + DEVICE_COMPILER: (HIPCC, 4.3), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, OFF), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, OFF), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, ON), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, OFF), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, ON), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, ON), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, OFF), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, ON), + } + ), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + ] + ) + + expected_results = parse_expected_val_pairs( + [ + OD( + { + HOST_COMPILER: (CLANG_CUDA, 16), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, ON), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, ON), + DEVICE_COMPILER: (HIPCC, 4.3), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, OFF), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, OFF), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, ON), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, OFF), + } + ), + OD( + { + ALPAKA_ACC_GPU_HIP_ENABLE: (ALPAKA_ACC_GPU_HIP_ENABLE, OFF), + ALPAKA_ACC_SYCL_ENABLE: (ALPAKA_ACC_SYCL_ENABLE, ON), + } + ), + OD({CMAKE: (CMAKE, 3.23), BOOST: (BOOST, 1.83)}), + ] + ) + + default_remove_test( + _remove_enabled_hip_and_sycl_backend_at_same_time, + test_param_value_pairs, + expected_results, + self, + ) + def test_remove_enabled_cuda_backend_for_hipcc(self): test_param_value_pairs: List[ParameterValuePair] = parse_expected_val_pairs( [ From 5698733031e2783c7554af4e9d4e62a5d08f33bd Mon Sep 17 00:00:00 2001 From: Simeon Ehrig Date: Mon, 23 Sep 2024 10:46:30 +0200 Subject: [PATCH 5/6] fix example with `remove_parameter_value_pairs_ranges()` --- example/example.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/example/example.py b/example/example.py index e5e5ea3..41b04a9 100644 --- a/example/example.py +++ b/example/example.py @@ -21,6 +21,7 @@ check_parameter_value_pair_in_combination_list, check_unexpected_parameter_value_pair_in_combination_list, remove_parameter_value_pairs, + remove_parameter_value_pairs_ranges, ) from bashi.results import get_expected_bashi_parameter_value_pairs from bashi.types import ( @@ -154,25 +155,29 @@ def verify(combination_list: CombinationList, param_value_matrix: ParameterValue max_supported_nvcc_gcc_version = max(comb.host for comb in NVCC_GCC_MAX_VERSION).major max_supported_nvcc_clang_version = max(comb.host for comb in NVCC_CLANG_MAX_VERSION).major for cpu_backend in cpu_backends: - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( expected_param_val_tuple, unexpected_param_val_tuple, parameter1=HOST_COMPILER, value_name1=GCC, - value_version1=f"<={max_supported_nvcc_gcc_version}", + value_min_version1=max_supported_nvcc_gcc_version, + value_min_version1_inclusive=False, parameter2=cpu_backend, value_name2=cpu_backend, - value_version2=OFF, + value_min_version2=OFF, + value_max_version2=OFF, ) - remove_parameter_value_pairs( + remove_parameter_value_pairs_ranges( expected_param_val_tuple, unexpected_param_val_tuple, parameter1=HOST_COMPILER, value_name1=CLANG, - value_version1=f"<={max_supported_nvcc_clang_version}", + value_min_version1=max_supported_nvcc_clang_version, + value_min_version1_inclusive=False, parameter2=cpu_backend, value_name2=cpu_backend, - value_version2=OFF, + value_min_version2=OFF, + value_max_version2=OFF, ) def all_cpu_backends_are(expected_state: pkv.Version, combination: Combination) -> bool: From 5ebcf02f939e9a917cb140883d198650ade8b1ec Mon Sep 17 00:00:00 2001 From: Simeon Ehrig Date: Mon, 23 Sep 2024 11:41:32 +0200 Subject: [PATCH 6/6] add guide for using remove_parameter_value_pairs() and remove_parameter_value_pairs_range() --- README.md | 4 + docs/remove-parameter-value-pairs.md | 127 +++++++++++++++++++++++++++ src/bashi/results.py | 3 +- 3 files changed, 133 insertions(+), 1 deletion(-) create mode 100644 docs/remove-parameter-value-pairs.md diff --git a/README.md b/README.md index 1e80161..7a6354a 100644 --- a/README.md +++ b/README.md @@ -71,6 +71,10 @@ This section contains some hints for developing new functions. The hints are mai Writing a new filter rule can be complicated. That's why we offer a [best practice guide](docs/rules.md). +## Removing expected parameter-values + +`bashi` offers the option of checking the generated combination-list for expected and unexpected parameter-value-pairs. To do this, `bashi` first generates all possible parameter-value-pairs from the input parameter-values and then removes unexpected parameter-values. `bashi` supports common cases of removing parameter-value-pairs with some util functions. Read the [guide for removing parameter-value-pairs](./docs/remove-parameter-value-pairs.md) for more information about util functions. + ## Formatting the Source Code The source code is formatted using the [black](https://pypi.org/project/black/) formatter and the default style guide. You must install it and run `black /path/to/file` to format a file. A CI job checks that all files are formatted correctly. If the job fails, a PR cannot be merged. diff --git a/docs/remove-parameter-value-pairs.md b/docs/remove-parameter-value-pairs.md new file mode 100644 index 0000000..ff8f6ec --- /dev/null +++ b/docs/remove-parameter-value-pairs.md @@ -0,0 +1,127 @@ +# Remove unexpected parameter-values-pairs + +The `get_expected_parameter_value_pairs()` function generates a list of all possible parameter-value-pairs. The functions `check_parameter_value_pair_in_combination_list()` and `check_unexpected_parameter_value_pair_in_combination_list` search for expected and unexpected parameter-value-pairs in a combination list. Unexpected parameter-value-pairs exist because the filter rules do not allow all possible combinations of parameter-values. The following functions help to remove unexpected parameter-value-pairs from a list of parameter-value-pairs. + +## remove_parameter_value_pairs() + +The `remove_parameter_value_pairs()` function searches for specific parameters, value-names and value-versions in each parameter value of a parameter-value-pair. + +```python +# remove all pairs, which contains host compiler nvcc +remove_parameter_value_pairs( + parameter_value_pairs, + removed_parameter_value_pairs, + parameter1=HOST_COMPILER, + value_name1=NVCC, + ) + +# remove all pairs, which contains the host compiler GCC 12 +remove_parameter_value_pairs( + parameter_value_pairs, + removed_parameter_value_pairs, + parameter1=HOST_COMPILER, + value_name1=GCC, + value_version1=12, + ) + +# remove the pair with device compiler Clang 17 and CUDA Backend version 12.5 +remove_parameter_value_pairs( + parameter_value_pairs, + removed_parameter_value_pairs, + parameter1=DEVICE_COMPILER, + value_name1=Clang, + value_version1=17, + parameter2=ALPAKA_ACC_CUDA_ENABLE, + value_name2=ALPAKA_ACC_CUDA_ENABLE, + value_version2=12.5, + ) +``` + +## remove_parameter_value_pairs_ranges() + +The `remove_parameter_value_pairs_ranges()` function also removes all parameter-value-pairs from a list, but for specific versions ranges. The matching of parameter and value-names works in the same way as with `remove_parameter_value_pairs()`. + +The version range to be removed is defined by a minimum and a maximum version. By default, both ends of the version range are open. The version range is restricted by the arguments `value_min_versionX` and `value_max_versionX`. + +The following examples show how to define specific ranges to be removed. For the example, we assume that we have major versions from 1 to 9. + +```python +# all major version before removed: [1,2,3,4,5,6,7,8,9] + +# all ranges are open, therefore remove all versions +remove_parameter_value_pairs_range( + # ... +) # -> output [] + +# minimum version to be remove is 3 +remove_parameter_value_pairs_range( + # ... + value_min_version1=3 +) # -> output [1,2] + +# minimum version to be remove is 3 +# 3 is excluded from the range of version to be removed +remove_parameter_value_pairs_range( + # ... + value_min_version1=3, + value_min_version1_inclusive=False +) # -> output [1,2,3] + +# maximum version to be remove is 6 +remove_parameter_value_pairs_range( + # ... + value_max_version1=6 +) # -> output [7,8,9] + +# maximum version to be remove is 6 +# 6 is excluded from the range of version to be removed +remove_parameter_value_pairs_range( + # ... + value_max_version1=6, + value_max_version1_inclusive=False +) # -> output [6,7,8,9] + +# remove all version between 4 and 8 +remove_parameter_value_pairs_range( + # ... + value_min_version1=4, + value_max_version1=8, +) # -> output [1,2,3,9] + +# remove all version between 4 and 8 +# exclude borders +remove_parameter_value_pairs_range( + # ... + value_min_version1=4, + value_min_version1_inclusive=False + value_max_version1=8, + value_max_version1_inclusive=False +) # -> output [1,2,3,4,8,9] + +# remove only version 5 +remove_parameter_value_pairs_range( + # ... + value_min_version1=5, + value_max_version1=5, +) # -> output [1,2,3,4,6,7,8,9] +``` + +### back-end versions + +All back-ends in `bashi` except the CUDA back-end have the states `OFF` or `ON`, which are internally represented by the versions 0.0.0 and 1.0.0. Therefore, ranges can be defined to remove all enabled or disabled back-ends, regardless of whether it is a CUDA or non-CUDA back-end. + +```python +# remove all enabled back-ends +# all enabled backends has a version higher than 0.0.0 +remove_parameter_value_pairs_range( + # ... + value_min_version1=OFF, + value_min_version1_inclusive=False +) + +# use remove_parameter_value_pairs() to remove the disabled back-ends (single version) +remove_parameter_value_pairs( + # ... + value_version1=OFF, +) +``` diff --git a/src/bashi/results.py b/src/bashi/results.py index a13700f..cfcc20f 100644 --- a/src/bashi/results.py +++ b/src/bashi/results.py @@ -847,7 +847,8 @@ def _remove_all_rocm_images_older_than_ubuntu2004_based( value_max_version1_inclusive=False, parameter2=ALPAKA_ACC_GPU_HIP_ENABLE, value_name2=ALPAKA_ACC_GPU_HIP_ENABLE, - value_min_version2=ON, + value_min_version2=OFF, + value_min_version2_inclusive=False, ) for compiler_type in (HOST_COMPILER, DEVICE_COMPILER): remove_parameter_value_pairs_ranges(