Commit 5cc1bddc authored by Carolina Jubran's avatar Carolina Jubran Committed by Jakub Kicinski
Browse files

selftests: drv-net: Fix tolerance calculation in devlink_rate_tc_bw.py 



Currently, tolerance is computed against the TC’s expected percentage,
making TC3 (20%) validation overly strict and TC4 (80%) overly loose.

Update BandwidthValidator to take a dict of shares and compute bounds
relative to the overall total, so that all shares are validated
consistently.

Signed-off-by: default avatarCarolina Jubran <cjubran@nvidia.com>
Reviewed-by: default avatarCosmin Ratiu <cratiu@nvidia.com>
Reviewed-by: default avatarNimrod Oren <noren@nvidia.com>
Link: https://patch.msgid.link/20251130091938.4109055-7-cjubran@nvidia.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 9ecd05a2

tools/testing/selftests/drivers/net/hw/devlink_rate_tc_bw.py

+30 −44
Original line number Diff line number Diff line
@@ -69,39 +69,35 @@ from lib.py import Iperf3Runner 


class BandwidthValidator:

    """

    Validates bandwidth totals and per-TC shares against expected values

    with a tolerance.

    Validates total bandwidth and individual shares with tolerance

    relative to the overall total.

    """



    def __init__(self):

    def __init__(self, shares):

        self.tolerance_percent = 12

        self.expected_total_gbps = 1.0

        self.total_min_expected = self.min_expected(self.expected_total_gbps)

        self.total_max_expected = self.max_expected(self.expected_total_gbps)

        self.tc_expected_percent = {

            3: 20.0,

            4: 80.0,

        }

        self.expected_total = sum(shares.values())

        self.bounds = {}



        for name, exp in shares.items():

            self.bounds[name] = (self.min_expected(exp), self.max_expected(exp))



    def min_expected(self, value):

        """Calculates the minimum acceptable value based on tolerance."""

        return value - (value * self.tolerance_percent / 100)

        return value - (self.expected_total * self.tolerance_percent / 100)



    def max_expected(self, value):

        """Calculates the maximum acceptable value based on tolerance."""

        return value + (value * self.tolerance_percent / 100)



    def bound(self, expected, value):

        """Returns True if value is within expected tolerance."""

        return self.min_expected(expected) <= value <= self.max_expected(expected)

        return value + (self.expected_total * self.tolerance_percent / 100)



    def tc_bandwidth_bound(self, value, tc_ix):

    def bound(self, values):

        """

        Returns True if the given bandwidth value is within tolerance

        for the TC's expected bandwidth.

        Return True if all given values fall within tolerance.

        """

        expected = self.tc_expected_percent[tc_ix]

        return self.bound(expected, value)

        for name, value in values.items():

            low, high = self.bounds[name]

            if not low <= value <= high:

                return False

        return True





def setup_vf(cfg, set_tc_mapping=True):
@@ -353,38 +349,26 @@ def verify_total_bandwidth(bw_data, validator): 
    """

    total = bw_data['total_bw']



    if validator.bound(validator.expected_total_gbps, total):

    if validator.bound({"total": total}):

        return



    if total < validator.total_min_expected:

    low, high = validator.bounds["total"]



    if total < low:

        raise KsftSkipEx(

            f"Total bandwidth {total:.2f} Gbps < minimum "

            f"{validator.total_min_expected:.2f} Gbps; "

            f"parent tx_max ({validator.expected_total_gbps:.1f} G) "

            f"{low:.2f} Gbps; "

            f"parent tx_max ({validator.expected_total:.1f} G) "

            f"not reached, cannot validate share"

        )



    raise KsftFailEx(

        f"Total bandwidth {total:.2f} Gbps exceeds allowed ceiling "

        f"{validator.total_max_expected:.2f} Gbps "

        f"(VF tx_max set to {validator.expected_total_gbps:.1f} G)"

        f"{high:.2f} Gbps "

        f"(VF tx_max set to {validator.expected_total:.1f} G)"

    )





def check_bandwidth_distribution(bw_data, validator):

    """

    Checks whether the measured TC3 and TC4 bandwidth percentages

    fall within their expected tolerance ranges.



    Returns:

        bool: True if both TC3 and TC4 percentages are within bounds.

    """

    tc3_valid = validator.tc_bandwidth_bound(bw_data['tc3_percentage'], 3)

    tc4_valid = validator.tc_bandwidth_bound(bw_data['tc4_percentage'], 4)



    return tc3_valid and tc4_valid





def run_bandwidth_distribution_test(cfg, set_tc_mapping):

    """

    Runs parallel bandwidth measurements for both TCs and collects results.
@@ -395,9 +379,10 @@ def run_bandwidth_distribution_test(cfg, set_tc_mapping): 
    test_name = "with TC mapping" if set_tc_mapping else "without TC mapping"

    print_bandwidth_results(bw_data, test_name)



    verify_total_bandwidth(bw_data, cfg.bw_validator)

    verify_total_bandwidth(bw_data, cfg.traffic_bw_validator)



    return check_bandwidth_distribution(bw_data, cfg.bw_validator)

    return cfg.tc_bw_validator.bound({"tc3": bw_data['tc3_percentage'],

                                     "tc4": bw_data['tc4_percentage']})





def test_no_tc_mapping_bandwidth(cfg):
@@ -441,7 +426,8 @@ def main() -> None: 
        if not cfg.pci:

            raise KsftSkipEx("Could not get PCI address of the interface")



        cfg.bw_validator = BandwidthValidator()

        cfg.traffic_bw_validator = BandwidthValidator({"total": 1})

        cfg.tc_bw_validator = BandwidthValidator({"tc3": 20, "tc4": 80})



        cases = [test_no_tc_mapping_bandwidth, test_tc_mapping_bandwidth]