diff --git a/tests/packet_trimming/base_packet_trimming.py b/tests/packet_trimming/base_packet_trimming.py index cd21dcca3b5..1f9e298f82a 100644 --- a/tests/packet_trimming/base_packet_trimming.py +++ b/tests/packet_trimming/base_packet_trimming.py @@ -6,8 +6,9 @@ from tests.common.utilities import wait_until, configure_packet_aging from tests.common.mellanox_data import is_mellanox_device from tests.packet_trimming.constants import ( - TRIM_SIZE, DEFAULT_PACKET_SIZE, DEFAULT_DSCP, MIN_PACKET_SIZE, TRIM_SIZE_MAX, CONFIG_TOGGLE_COUNT, - JUMBO_PACKET_SIZE, PORT_TOGGLE_COUNT, COUNTER_DSCP, TRIM_QUEUE) + DEFAULT_PACKET_SIZE, DEFAULT_DSCP, MIN_PACKET_SIZE, CONFIG_TOGGLE_COUNT, + JUMBO_PACKET_SIZE, PORT_TOGGLE_COUNT, COUNTER_DSCP) +from tests.packet_trimming.packet_trimming_config import PacketTrimmingConfig from tests.packet_trimming.packet_trimming_helper import ( configure_trimming_action, configure_trimming_acl, verify_srv6_packet_with_trimming, cleanup_trimming_acl, verify_trimmed_packet, reboot_dut, check_connected_route_ready, get_switch_trim_counters_json, @@ -24,38 +25,38 @@ def configure_trimming_global_by_mode(self, duthost): def get_srv6_recv_pkt_dscp(self): raise NotImplementedError - def get_verify_trimmed_packet_kwargs(self, test_params): + def get_verify_trimmed_packet_kwargs(self, duthost, ptfadapter, test_params): """ Get kwargs for verify_trimmed_packet """ base_kwargs = dict( - duthost=test_params.get('duthost'), - ptfadapter=test_params.get('ptfadapter'), + duthost=duthost, + ptfadapter=ptfadapter, ingress_port=test_params['ingress_port'], egress_ports=test_params['egress_ports'], block_queue=test_params['block_queue'], send_pkt_size=DEFAULT_PACKET_SIZE, send_pkt_dscp=DEFAULT_DSCP, - recv_pkt_size=TRIM_SIZE, + recv_pkt_size=PacketTrimmingConfig.get_trim_size(duthost), expect_packets=True ) base_kwargs.update(self.get_extra_trimmed_packet_kwargs()) logger.info(f"Base kwargs: {base_kwargs}") return base_kwargs - def get_verify_trimmed_counter_packet_kwargs(self, trim_counter_params): + def get_verify_trimmed_counter_packet_kwargs(self, duthost, ptfadapter, trim_counter_params): """ Get kwargs for verify_trimmed_packet """ base_kwargs = dict( - duthost=trim_counter_params.get('duthost'), - ptfadapter=trim_counter_params.get('ptfadapter'), + duthost=duthost, + ptfadapter=ptfadapter, ingress_port=trim_counter_params['ingress_port'], egress_ports=trim_counter_params['egress_ports'], block_queue=trim_counter_params['block_queue'], send_pkt_size=DEFAULT_PACKET_SIZE, send_pkt_dscp=COUNTER_DSCP, - recv_pkt_size=TRIM_SIZE, + recv_pkt_size=PacketTrimmingConfig.get_trim_size(duthost), expect_packets=True ) base_kwargs.update(self.get_extra_trimmed_packet_kwargs()) @@ -84,20 +85,18 @@ def test_packet_size_after_trimming(self, duthost, ptfadapter, test_params): configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") with allure.step("Verify trimming packet"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) - with allure.step(f"Configure trimming in {self.trimming_mode} mode and update trim size to {TRIM_SIZE_MAX}"): - self.configure_trimming_global_by_mode(duthost, TRIM_SIZE_MAX) + max_trim_size = PacketTrimmingConfig.get_max_trim_size(duthost) + with allure.step(f"Configure trimming in {self.trimming_mode} mode and update trim size to {max_trim_size}"): + self.configure_trimming_global_by_mode(duthost, max_trim_size) with allure.step("Send packets and verify trimming works after config update"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) kwargs.update({ - 'duthost': duthost, - 'ptfadapter': ptfadapter, 'send_pkt_size': JUMBO_PACKET_SIZE, - 'recv_pkt_size': TRIM_SIZE_MAX + 'recv_pkt_size': max_trim_size }) verify_trimmed_packet(**kwargs) @@ -118,16 +117,13 @@ def test_dscp_remapping_after_trimming(self, duthost, ptfadapter, test_params): configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") with allure.step("Verify trimming packet"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) # When packet size is less than trimming size, the packet is not trimmed, but the DSCP value should be updated with allure.step("Verify trim packet when packets size less than trimming size"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) kwargs.update({ - 'duthost': duthost, - 'ptfadapter': ptfadapter, 'send_pkt_size': MIN_PACKET_SIZE, 'recv_pkt_size': MIN_PACKET_SIZE }) @@ -149,28 +145,22 @@ def test_acl_action_with_trimming(self, duthost, ptfadapter, test_params, clean_ configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") with allure.step("Verify trimming packet"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Config ACL rule with DISABLE_TRIM_ACTION action"): configure_trimming_acl(duthost, test_params['ingress_port']['name']) with allure.step("Verify packets are dropped directly"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({ - 'duthost': duthost, - 'ptfadapter': ptfadapter, - 'expect_packets': False - }) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) + kwargs.update({'expect_packets': False}) verify_trimmed_packet(**kwargs) with allure.step("Remove ACL table"): cleanup_trimming_acl(duthost) with allure.step("Send packets again and verify trimmed packets"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) def test_trimming_with_srv6(self, duthost, ptfadapter, setup_srv6, test_params): @@ -198,7 +188,7 @@ def test_trimming_with_srv6(self, duthost, ptfadapter, setup_srv6, test_params): block_queue=test_params['block_queue'], send_pkt_size=DEFAULT_PACKET_SIZE, send_pkt_dscp=DEFAULT_DSCP, - recv_pkt_size=TRIM_SIZE, + recv_pkt_size=PacketTrimmingConfig.get_trim_size(duthost), recv_pkt_dscp=recv_pkt_dscp ) @@ -216,8 +206,7 @@ def test_stability_during_feature_toggles(self, duthost, ptfadapter, test_params with allure.step(f"Config and verify trimming in {self.trimming_mode} mode"): self.configure_trimming_global_by_mode(duthost) - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Disable trimming"): @@ -226,12 +215,8 @@ def test_stability_during_feature_toggles(self, duthost, ptfadapter, test_params with allure.step(f"Verify no trimming action in {self.trimming_mode} mode when disable trimming"): self.configure_trimming_global_by_mode(duthost) - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({ - 'duthost': duthost, - 'ptfadapter': ptfadapter, - 'expect_packets': False - }) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) + kwargs.update({'expect_packets': False}) verify_trimmed_packet(**kwargs) with allure.step("Enable trimming again"): @@ -240,8 +225,7 @@ def test_stability_during_feature_toggles(self, duthost, ptfadapter, test_params with allure.step(f"Verify trimming in {self.trimming_mode} mode after enable trimming"): self.configure_trimming_global_by_mode(duthost) - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Trimming config toggles"): @@ -253,8 +237,7 @@ def test_stability_during_feature_toggles(self, duthost, ptfadapter, test_params with allure.step(f"Verify trimming still works after feature toggles in {self.trimming_mode} mode"): self.configure_trimming_global_by_mode(duthost) - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) def test_trimming_during_port_admin_toggle(self, duthost, ptfadapter, test_params): @@ -273,8 +256,7 @@ def test_trimming_during_port_admin_toggle(self, duthost, ptfadapter, test_param configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") with allure.step("Verify trimming packet"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Ports admin status toggles"): @@ -292,8 +274,7 @@ def test_trimming_during_port_admin_toggle(self, duthost, ptfadapter, test_param "Connected route is not ready") with allure.step("Verify trimming still works after admin toggles"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Verify packet trimming counter"): @@ -317,8 +298,7 @@ def test_trimming_with_reload_and_reboot(self, duthost, ptfadapter, test_params, configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") with allure.step("Verify trimming packet"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Randomly choose one action from reload/cold reboot"): @@ -347,8 +327,7 @@ def test_trimming_with_reload_and_reboot(self, duthost, ptfadapter, test_params, configure_packet_aging(duthost, disabled=True) with allure.step(f"Verify trimming function in {self.trimming_mode} mode after reload/cold reboot"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) with allure.step("Verify packet trimming counter"): @@ -372,8 +351,7 @@ def test_trimming_counters(self, duthost, ptfadapter, test_params, trim_counter_ # Packets are trimmed on two queues, verify trimming counters in queue and port level with allure.step("Verify trimming counters on two queues"): # Trigger trimmed packets on queue0 - counter_kwargs = self.get_verify_trimmed_counter_packet_kwargs({**trim_counter_params}) - counter_kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + counter_kwargs = self.get_verify_trimmed_counter_packet_kwargs(duthost, ptfadapter, {**trim_counter_params}) verify_trimmed_packet(**counter_kwargs) # Verify the consistency of the trim counter on the queue and the port level @@ -399,18 +377,20 @@ def test_trimming_counters(self, duthost, ptfadapter, test_params, trim_counter_ "Trim sent counter on switch level is not equal to the sum of trim sent counter on port " "level") + trim_queue = PacketTrimmingConfig.get_trim_queue(duthost) + with allure.step("Verify TrimDrop counters on switch level"): original_schedulers = {} try: # Block the trimmed queue for port in trim_counter_params['egress_ports']: for dut_member in port['dut_members']: - original_scheduler = disable_egress_data_plane(duthost, dut_member, TRIM_QUEUE) + original_scheduler = disable_egress_data_plane(duthost, dut_member, trim_queue) original_schedulers[dut_member] = original_scheduler # Trigger trimmed packets on queue6 - counter_kwargs = self.get_verify_trimmed_counter_packet_kwargs({**trim_counter_params}) - counter_kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter, 'expect_packets': False}) + counter_kwargs = self.get_verify_trimmed_counter_packet_kwargs(duthost, ptfadapter, {**trim_counter_params}) + counter_kwargs.update({'expect_packets': False}) verify_trimmed_packet(**counter_kwargs) # Get the TrimDrop counters on switch level @@ -423,10 +403,10 @@ def test_trimming_counters(self, duthost, ptfadapter, test_params, trim_counter_ for port in trim_counter_params['egress_ports']: for dut_member in port['dut_members']: original_scheduler = original_schedulers.get(dut_member) - enable_egress_data_plane(duthost, dut_member, TRIM_QUEUE, original_scheduler) + enable_egress_data_plane(duthost, dut_member, trim_queue, original_scheduler) with allure.step("Verify trimming counter when trimming feature toggles"): - trim_queue = 'UC'+str(TRIM_QUEUE) + trim_queue = 'UC'+str(trim_queue) # Get queue level and port level counter when trimming is enabled port = test_params['egress_ports'][0]['dut_members'][0] diff --git a/tests/packet_trimming/constants.py b/tests/packet_trimming/constants.py index 5107ace2f00..63112afb516 100644 --- a/tests/packet_trimming/constants.py +++ b/tests/packet_trimming/constants.py @@ -1,33 +1,4 @@ -# Default values for trimming configuration -TRIM_SIZE = 256 -TRIM_DSCP = 48 -TRIM_QUEUE = 6 -TRIM_SIZE_MAX = 4084 - -VALID_TRIMMING_CONFIGS_SYM = [ - (300, 32, 5), # Valid values - (256, 0, 0), # Min Boundary values - (4084, 63, 7) # Max Boundary values -] - -INVALID_TRIMMING_CONFIGS_SYM = [ - (1.1, 32, 5), # Invalid size value - (256, -1, 5), # Invalid dscp value - (256, 63, -3.0) # Invalid queue value -] - -VALID_TRIMMING_CONFIGS_ASYM = [ - (300, 'from-tc', 3, 5), # Valid values - (256, 'from-tc', 0, 0), # Min Boundary values - (4084, 'from-tc', 6, 14) # Max Boundary values -] - -INVALID_TRIMMING_CONFIGS_ASYM = [ - (1.1, 'from-tc', 3, 5), # Invalid size value - (256, 'test', 3, 5), # Invalid dscp value - (256, 'from-tc', -3.0, 5), # Invalid queue value - (300, 'from-tc', 3, 256) # Invalid tc value -] +from tests.packet_trimming.packet_trimming_config import PacketTrimmingConfig # ACL configuration constants ACL_TABLE_TYPE_NAME = "TRIMMING_L3" @@ -63,7 +34,6 @@ STATIC_THRESHOLD_MULTIPLIER = 1.5 # Multiplier to ensure the buffer can be fully exhausted # Asymmetric DSCP constants -ASYM_TC = TRIM_QUEUE ASYM_PORT_1_DSCP = 10 ASYM_PORT_2_DSCP = 20 @@ -115,7 +85,7 @@ 'dst_ipv6': '2001:1000:0100:0200::', 'exp_dst_ipv6': '2001:1000:0200::', 'exp_inner_dscp_pipe': None, - 'exp_outer_dscp_uniform': TRIM_DSCP << 2, + 'exp_outer_dscp_uniform': PacketTrimmingConfig.DSCP << 2, 'exp_srh_seg_left': None, 'inner_pkt_ver': '4', 'exp_process_result': 'forward', @@ -133,7 +103,7 @@ 'dst_ipv6': '2001:3000:0500::', 'exp_dst_ipv6': '2001:3000:0500:0600::', 'exp_inner_dscp_pipe': None, - 'exp_outer_dscp_uniform': TRIM_DSCP << 2, + 'exp_outer_dscp_uniform': PacketTrimmingConfig.DSCP << 2, 'exp_srh_seg_left': 0, 'inner_pkt_ver': '4', 'exp_process_result': 'forward' diff --git a/tests/packet_trimming/packet_trimming_config.py b/tests/packet_trimming/packet_trimming_config.py new file mode 100644 index 00000000000..88013e4f46e --- /dev/null +++ b/tests/packet_trimming/packet_trimming_config.py @@ -0,0 +1,85 @@ +class PacketTrimmingConfig: + DSCP = 48 + + @staticmethod + def get_trim_size(duthost): + if duthost.get_asic_name() == 'th5': + return 206 + else: + return 256 + + @staticmethod + def get_max_trim_size(duthost): + if duthost.get_asic_name() == 'th5': + # th5 only supports a trim size of 206 + return 206 + else: + return 4084 + + @staticmethod + def get_trim_queue(duthost): + if duthost.get_asic_name() == 'th5': + return 4 + else: + return 6 + + @staticmethod + def get_valid_trim_configs(duthost, asymmetric=False): + configs = { + 'th5': { + 'symmetric': [ + (206, 48, 4) + ], + 'asymmetric': [ + (206, 'from-tc', 4, 5) + ] + }, + 'default': { + 'symmetric': [ + (300, 32, 5), # Valid values + (256, 0, 0), # Min Boundary values + (4084, 63, 7) # Max Boundary values + ], + 'asymmetric': [ + (300, 'from-tc', 3, 5), # Valid values + (256, 'from-tc', 0, 0), # Min Boundary values + (4084, 'from-tc', 6, 14) # Max Boundary values + ] + } + } + + asic_name = duthost.get_asic_name() + key = 'asymmetric' if asymmetric else 'symmetric' + if asic_name in configs.keys(): + return configs[asic_name][key] + else: + return configs['default'][key] + + @staticmethod + def get_invalid_trim_configs(duthost, asymmetric=False): + configs = { + 'default': { + 'symmetric': [ + (1.1, 32, 5), # Invalid size value + (256, -1, 5), # Invalid dscp value + (256, 63, -3.0) # Invalid queue value + ], + 'asymmetric': [ + (1.1, 'from-tc', 3, 5), # Invalid size value + (256, 'test', 3, 5), # Invalid dscp value + (256, 'from-tc', -3.0, 5), # Invalid queue value + (300, 'from-tc', 3, 256) # Invalid tc value + ] + } + } + + asic_name = duthost.get_asic_name() + key = 'asymmetric' if asymmetric else 'symmetric' + if asic_name in configs.keys(): + return configs[asic_name][key] + else: + return configs['default'][key] + + @staticmethod + def get_asym_tc(duthost): + return PacketTrimmingConfig.get_trim_queue(duthost) diff --git a/tests/packet_trimming/packet_trimming_helper.py b/tests/packet_trimming/packet_trimming_helper.py index 4e99b208bfb..ac9ab806226 100644 --- a/tests/packet_trimming/packet_trimming_helper.py +++ b/tests/packet_trimming/packet_trimming_helper.py @@ -18,13 +18,14 @@ from tests.common.reboot import reboot from tests.packet_trimming.constants import (DEFAULT_SRC_PORT, DEFAULT_DST_PORT, DEFAULT_TTL, DUMMY_MAC, DUMMY_IPV6, DUMMY_IP, BATCH_PACKET_COUNT, PACKET_COUNT, STATIC_THRESHOLD_MULTIPLIER, - BLOCK_DATA_PLANE_SCHEDULER_NAME, TRIM_QUEUE, PACKET_TYPE, SRV6_PACKETS, + BLOCK_DATA_PLANE_SCHEDULER_NAME, PACKET_TYPE, SRV6_PACKETS, TRIM_QUEUE_PROFILE, TRIMMING_CAPABILITY, ACL_TABLE_NAME, ACL_RULE_PRIORITY, ACL_TABLE_TYPE_NAME, ACL_RULE_NAME, SRV6_MY_SID_LIST, SRV6_INNER_SRC_IP, SRV6_INNER_DST_IP, DEFAULT_QUEUE_SCHEDULER_CONFIG, SRV6_UNIFORM_MODE, SRV6_OUTER_SRC_IPV6, SRV6_INNER_SRC_IPV6, ECN, - SRV6_INNER_DST_IPV6, SRV6_UN, ASYM_TC, ASYM_PORT_1_DSCP, ASYM_PORT_2_DSCP, + SRV6_INNER_DST_IPV6, SRV6_UN, ASYM_PORT_1_DSCP, ASYM_PORT_2_DSCP, SCHEDULER_TYPE, SCHEDULER_WEIGHT, SCHEDULER_PIR) +from tests.packet_trimming.packet_trimming_config import PacketTrimmingConfig logger = logging.getLogger(__name__) @@ -788,7 +789,7 @@ def fill_egress_buffer(duthost, ptfadapter, port_id, buffer_size, target_queue, def verify_packet_trimming(duthost, ptfadapter, ingress_port, egress_port, block_queue, send_pkt_size, - send_pkt_dscp, recv_pkt_size, recv_pkt_dscp, packet_count=PACKET_COUNT, timeout=5, + send_pkt_dscp, recv_pkt_size, recv_pkt_dscp, packet_count, timeout=5, fill_buffer=True, expect_packets=True): """ Verify packet trimming for all packet types with given parameters. @@ -1498,7 +1499,7 @@ def cleanup_trimming_acl(duthost): def set_buffer_profiles_for_block_and_trim_queues(duthost, interfaces, block_queue_id, - block_queue_profile, trim_queue_id=TRIM_QUEUE, + block_queue_profile, trim_queue_id=None, trim_queue_profile=TRIM_QUEUE_PROFILE): """ Set buffer profiles for blocked queue and forward trimming packet queue. @@ -1508,7 +1509,7 @@ def set_buffer_profiles_for_block_and_trim_queues(duthost, interfaces, block_que interfaces (list or str): Port names to configure, can be a list or single string block_queue_id: Queue index used for blocking traffic block_queue_profile (str): Buffer profile name to apply for blocking queue - trim_queue_id (int): Queue index used for packet trimming (default: TRIM_QUEUE) + trim_queue_id (int): Queue index used for packet trimming (default: trim queue from packet_trimming_config) trim_queue_profile (str): Buffer profile name to apply for trimming queue (default: TRIM_QUEUE_PROFILE) Raises: @@ -1516,7 +1517,7 @@ def set_buffer_profiles_for_block_and_trim_queues(duthost, interfaces, block_que """ # Convert queue indices to string for Redis commands block_queue_id = str(block_queue_id) - trim_queue_id = str(trim_queue_id) + trim_queue_id = str(trim_queue_id) if trim_queue_id else str(PacketTrimmingConfig.get_trim_queue(duthost)) logger.info(f"Setting blocking queue ({block_queue_id}) buffer profile to '{block_queue_profile}' and " f"trimming queue ({trim_queue_id}) buffer profile to '{trim_queue_profile}', ports: {interfaces}") @@ -2413,7 +2414,7 @@ def configure_tc_to_dscp_map(duthost, egress_ports): """ logger.info("Configuring TC_TO_DSCP_MAP for asymmetric DSCP") - tc_to_dscp_map = {"spine_trim_map": {ASYM_TC: ASYM_PORT_1_DSCP}} + tc_to_dscp_map = {"spine_trim_map": {PacketTrimmingConfig.get_asym_tc(duthost): ASYM_PORT_1_DSCP}} port_qos_map = {} # Handle first egress port (spine_trim_map) @@ -2423,7 +2424,7 @@ def configure_tc_to_dscp_map(duthost, egress_ports): logger.info(f"Applied spine_trim_map to interfaces: {egress_ports[0]['dut_members']}") if len(egress_ports) == 2: - tc_to_dscp_map["host_trim_map"] = {ASYM_TC: ASYM_PORT_2_DSCP} + tc_to_dscp_map["host_trim_map"] = {PacketTrimmingConfig.get_asym_tc(duthost): ASYM_PORT_2_DSCP} # Handle second egress port (host_trim_map) # Apply to all member interfaces @@ -2528,7 +2529,8 @@ def verify_trimmed_packet( send_pkt_dscp=send_pkt_dscp, recv_pkt_size=recv_pkt_size, recv_pkt_dscp=dscp, - expect_packets=expect_packets + expect_packets=expect_packets, + packet_count=PACKET_COUNT ) diff --git a/tests/packet_trimming/test_packet_trimming_asymmetric.py b/tests/packet_trimming/test_packet_trimming_asymmetric.py index e2c42904c78..9d7f3c452e7 100644 --- a/tests/packet_trimming/test_packet_trimming_asymmetric.py +++ b/tests/packet_trimming/test_packet_trimming_asymmetric.py @@ -3,9 +3,10 @@ from tests.common.helpers.assertions import pytest_assert from tests.common.plugins.allure_wrapper import allure_step_wrapper as allure from tests.packet_trimming.constants import ( - TRIM_SIZE, TRIM_DSCP, DEFAULT_PACKET_SIZE, DEFAULT_DSCP, TRIM_SIZE_MAX, JUMBO_PACKET_SIZE, TRIM_QUEUE, ASYM_TC, - ASYM_PORT_1_DSCP, ASYM_PORT_2_DSCP, VALID_TRIMMING_CONFIGS_ASYM, INVALID_TRIMMING_CONFIGS_ASYM, MODE_TOGGLE_COUNT, - NORMAL_PACKET_DSCP) + DEFAULT_PACKET_SIZE, DEFAULT_DSCP, JUMBO_PACKET_SIZE, + ASYM_PORT_1_DSCP, ASYM_PORT_2_DSCP, MODE_TOGGLE_COUNT, + NORMAL_PACKET_DSCP, PACKET_COUNT) +from tests.packet_trimming.packet_trimming_config import PacketTrimmingConfig from tests.packet_trimming.packet_trimming_helper import ( configure_trimming_global, verify_trimming_config, configure_trimming_action, verify_trimmed_packet, remove_tc_to_dscp_map, configure_tc_to_dscp_map, verify_normal_packet, verify_packet_trimming) @@ -22,11 +23,15 @@ class TestPacketTrimmingAsymmetric(BasePacketTrimming): trimming_mode = "asymmetric" - def configure_trimming_global_by_mode(self, duthost, size=TRIM_SIZE): + def configure_trimming_global_by_mode(self, duthost, size=None): """ Configure trimming global by trimming mode """ - configure_trimming_global(duthost, size=size, queue=TRIM_QUEUE, dscp='from-tc', tc=ASYM_TC) + if size is None: + size = PacketTrimmingConfig.get_trim_size(duthost) + queue = PacketTrimmingConfig.get_trim_queue(duthost) + asym_tc = PacketTrimmingConfig.get_asym_tc(duthost) + configure_trimming_global(duthost, size=size, queue=queue, dscp='from-tc', tc=asym_tc) def get_extra_trimmed_packet_kwargs(self): return dict( @@ -42,12 +47,12 @@ def test_trimming_configuration(self, duthost, test_params): Test Case: Verify Trimming Configuration """ with allure.step(f"Testing {self.trimming_mode} DSCP valid configurations"): - for size, dscp, queue, tc in VALID_TRIMMING_CONFIGS_ASYM: + for size, dscp, queue, tc in PacketTrimmingConfig.get_valid_trim_configs(duthost, asymmetric=True): logger.info(f"Testing valid config: size={size}, dscp={dscp}, queue={queue}, tc={tc}") pytest_assert(configure_trimming_global(duthost, size=size, queue=queue, dscp=dscp, tc=tc)) with allure.step(f"Testing {self.trimming_mode} DSCP invalid configurations"): - for size, dscp, queue, tc in INVALID_TRIMMING_CONFIGS_ASYM: + for size, dscp, queue, tc in PacketTrimmingConfig.get_invalid_trim_configs(duthost, asymmetric=True): logger.info(f"Testing invalid config: size={size}, dscp={dscp}, queue={queue}, tc={tc}") pytest_assert(not configure_trimming_global(duthost, size=size, queue=queue, dscp=dscp, tc=tc)) @@ -67,36 +72,36 @@ def test_packet_size_after_trimming(self, duthost, ptfadapter, test_params): configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") with allure.step("Verify trimming packet"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) - kwargs.update({'duthost': duthost, 'ptfadapter': ptfadapter}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) verify_trimmed_packet(**kwargs) - with allure.step(f"Configure trimming in {self.trimming_mode} mode and update trim size to {TRIM_SIZE_MAX}"): - self.configure_trimming_global_by_mode(duthost, TRIM_SIZE_MAX) + max_trim_size = PacketTrimmingConfig.get_max_trim_size(duthost) + with allure.step(f"Configure trimming in {self.trimming_mode} mode and update trim size to {max_trim_size}"): + self.configure_trimming_global_by_mode(duthost, max_trim_size) with allure.step("Send packets and verify trimming works after config update"): - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) kwargs.update({ - 'duthost': duthost, - 'ptfadapter': ptfadapter, 'send_pkt_size': JUMBO_PACKET_SIZE, - 'recv_pkt_size': TRIM_SIZE_MAX + 'recv_pkt_size': max_trim_size }) verify_trimmed_packet(**kwargs) + trim_size = PacketTrimmingConfig.get_trim_size(duthost) + trim_queue = PacketTrimmingConfig.get_trim_queue(duthost) + asym_tc = PacketTrimmingConfig.get_asym_tc(duthost) + with allure.step("Verify setting TC value while missing TC_TO_DSCP_MAP attached to the egress port"): remove_tc_to_dscp_map(duthost) - configure_trimming_global(duthost, size=TRIM_SIZE, queue=TRIM_QUEUE, dscp='from-tc', tc=ASYM_TC) - verify_trimming_config(duthost, size=TRIM_SIZE, queue=TRIM_QUEUE, dscp='from-tc', tc=ASYM_TC) + configure_trimming_global(duthost, size=trim_size, queue=trim_queue, dscp='from-tc', tc=asym_tc) + verify_trimming_config(duthost, size=trim_size, queue=trim_queue, dscp='from-tc', tc=asym_tc) with allure.step("Verify that trimming is configured before configuring tc_to_dscp_map"): configure_tc_to_dscp_map(duthost, test_params['egress_ports']) - kwargs = self.get_verify_trimmed_packet_kwargs({**test_params}) + kwargs = self.get_verify_trimmed_packet_kwargs(duthost, ptfadapter, {**test_params}) kwargs.update({ - 'duthost': duthost, - 'ptfadapter': ptfadapter, 'send_pkt_size': DEFAULT_PACKET_SIZE, - 'recv_pkt_size': TRIM_SIZE + 'recv_pkt_size': trim_size }) verify_trimmed_packet(**kwargs) @@ -108,9 +113,14 @@ def test_symmetric_asymmetric_mode_switch(self, duthost, ptfadapter, test_params for buffer_profile in test_params['trim_buffer_profiles']: configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") + trim_size = PacketTrimmingConfig.get_trim_size(duthost) + trim_queue = PacketTrimmingConfig.get_trim_queue(duthost) + asym_tc = PacketTrimmingConfig.get_asym_tc(duthost) + trim_dscp = PacketTrimmingConfig.DSCP + for i in range(MODE_TOGGLE_COUNT): with allure.step(f"Round {i+1}: Configure trimming in Symmetric DSCP mode"): - configure_trimming_global(duthost, size=TRIM_SIZE, queue=TRIM_QUEUE, dscp=TRIM_DSCP) + configure_trimming_global(duthost, size=trim_size, queue=trim_queue, dscp=trim_dscp) for egress_port in test_params['egress_ports']: verify_packet_trimming( duthost=duthost, @@ -120,12 +130,13 @@ def test_symmetric_asymmetric_mode_switch(self, duthost, ptfadapter, test_params block_queue=test_params['block_queue'], send_pkt_size=DEFAULT_PACKET_SIZE, send_pkt_dscp=DEFAULT_DSCP, - recv_pkt_size=TRIM_SIZE, - recv_pkt_dscp=TRIM_DSCP + recv_pkt_size=trim_size, + recv_pkt_dscp=trim_dscp, + packet_count=PACKET_COUNT ) with allure.step(f"Round {i+1}: Configure trimming in Asymmetric DSCP mode"): - configure_trimming_global(duthost, size=TRIM_SIZE, queue=TRIM_QUEUE, dscp='from-tc', tc=ASYM_TC) + configure_trimming_global(duthost, size=trim_size, queue=trim_queue, dscp='from-tc', tc=asym_tc) verify_trimmed_packet( duthost=duthost, ptfadapter=ptfadapter, @@ -134,7 +145,7 @@ def test_symmetric_asymmetric_mode_switch(self, duthost, ptfadapter, test_params block_queue=test_params['block_queue'], send_pkt_size=DEFAULT_PACKET_SIZE, send_pkt_dscp=DEFAULT_DSCP, - recv_pkt_size=TRIM_SIZE, + recv_pkt_size=trim_size, recv_pkt_dscp_port1=ASYM_PORT_1_DSCP, recv_pkt_dscp_port2=ASYM_PORT_2_DSCP ) @@ -147,8 +158,12 @@ def test_untrimmed_packet_in_asym_mode(self, duthost, ptfadapter, test_params): for buffer_profile in test_params['trim_buffer_profiles']: configure_trimming_action(duthost, test_params['trim_buffer_profiles'][buffer_profile], "on") + trim_size = PacketTrimmingConfig.get_trim_size(duthost) + trim_queue = PacketTrimmingConfig.get_trim_queue(duthost) + asym_tc = PacketTrimmingConfig.get_asym_tc(duthost) + with allure.step("Configure trimming in Asymmetric DSCP mode"): - configure_trimming_global(duthost, size=TRIM_SIZE, queue=TRIM_QUEUE, dscp='from-tc', tc=ASYM_TC) + configure_trimming_global(duthost, size=trim_size, queue=trim_queue, dscp='from-tc', tc=asym_tc) with allure.step("Verify trimming in Asymmetric DSCP mode"): verify_trimmed_packet( @@ -159,7 +174,7 @@ def test_untrimmed_packet_in_asym_mode(self, duthost, ptfadapter, test_params): block_queue=test_params['block_queue'], send_pkt_size=DEFAULT_PACKET_SIZE, send_pkt_dscp=DEFAULT_DSCP, - recv_pkt_size=TRIM_SIZE, + recv_pkt_size=trim_size, recv_pkt_dscp_port1=ASYM_PORT_1_DSCP, recv_pkt_dscp_port2=ASYM_PORT_2_DSCP ) diff --git a/tests/packet_trimming/test_packet_trimming_symmetric.py b/tests/packet_trimming/test_packet_trimming_symmetric.py index 85319576a52..5a5c7ec5fee 100644 --- a/tests/packet_trimming/test_packet_trimming_symmetric.py +++ b/tests/packet_trimming/test_packet_trimming_symmetric.py @@ -3,8 +3,7 @@ from tests.common.helpers.assertions import pytest_assert from tests.common.plugins.allure_wrapper import allure_step_wrapper as allure from tests.packet_trimming.base_packet_trimming import BasePacketTrimming -from tests.packet_trimming.constants import ( - TRIM_SIZE, TRIM_DSCP, TRIM_QUEUE, VALID_TRIMMING_CONFIGS_SYM, INVALID_TRIMMING_CONFIGS_SYM) +from tests.packet_trimming.packet_trimming_config import PacketTrimmingConfig from tests.packet_trimming.packet_trimming_helper import configure_trimming_global pytestmark = [ @@ -17,31 +16,35 @@ class TestPacketTrimmingSymmetric(BasePacketTrimming): trimming_mode = "symmetric" - def configure_trimming_global_by_mode(self, duthost, size=TRIM_SIZE): + def configure_trimming_global_by_mode(self, duthost, size=None): """ Configure trimming global by trimming mode """ - configure_trimming_global(duthost, size=size, queue=TRIM_QUEUE, dscp=TRIM_DSCP) + if size is None: + size = PacketTrimmingConfig.get_trim_size(duthost) + queue = PacketTrimmingConfig.get_trim_queue(duthost) + dscp = PacketTrimmingConfig.DSCP + configure_trimming_global(duthost, size=size, queue=queue, dscp=dscp) def get_extra_trimmed_packet_kwargs(self): return dict( - recv_pkt_dscp_port1=TRIM_DSCP, - recv_pkt_dscp_port2=TRIM_DSCP + recv_pkt_dscp_port1=PacketTrimmingConfig.DSCP, + recv_pkt_dscp_port2=PacketTrimmingConfig.DSCP ) def get_srv6_recv_pkt_dscp(self): - return TRIM_DSCP + return PacketTrimmingConfig.DSCP def test_trimming_configuration(self, duthost, test_params): """ Test Case: Verify Trimming Configuration """ with allure.step(f"Testing {self.trimming_mode} DSCP valid configurations"): - for size, dscp, queue in VALID_TRIMMING_CONFIGS_SYM: + for size, dscp, queue in PacketTrimmingConfig.get_valid_trim_configs(duthost): logger.info(f"Testing valid config: size={size}, dscp={dscp}, queue={queue}") pytest_assert(configure_trimming_global(duthost, size=size, queue=queue, dscp=dscp)) with allure.step(f"Testing {self.trimming_mode} DSCP invalid configurations"): - for size, dscp, queue in INVALID_TRIMMING_CONFIGS_SYM: + for size, dscp, queue in PacketTrimmingConfig.get_invalid_trim_configs(duthost): logger.info(f"Testing invalid config: size={size}, dscp={dscp}, queue={queue}") pytest_assert(not configure_trimming_global(duthost, size=size, queue=queue, dscp=dscp))