Add IPv6 Feature and Netperf test

Author: adityagesh

lisa/features/__init__.py

@@ -19,6 +19,7 @@
 from .gpu import Gpu, GpuEnabled, GpuSettings
 from .hibernation import Hibernation, HibernationEnabled, HibernationSettings
 from .infiniband import Infiniband
+from .ipv6 import IPv6
 from .isolated_resource import IsolatedResource
 from .nested_virtualization import NestedVirtualization
 from .network_interface import NetworkInterface, Sriov, Synthetic
@@ -54,6 +55,7 @@
     "HibernationEnabled",
     "HibernationSettings",
     "Infiniband",
+    "IPv6",
     "IsolatedResource",
     "NestedVirtualization",
     "Nfs",

lisa/features/ipv6.py

@@ -0,0 +1,23 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+from typing import Any, Type
+
+from lisa import schema
+from lisa.feature import Feature
+
+
+class IPv6(Feature):
+    @classmethod
+    def settings_type(cls) -> Type[schema.FeatureSettings]:
+        return schema.FeatureSettings
+
+    @classmethod
+    def can_disable(cls) -> bool:
+        return True
+
+    def enabled(self) -> bool:
+        raise NotImplementedError
+
+    def _initialize(self, *args: Any, **kwargs: Any) -> None:
+        pass

lisa/sut_orchestrator/azure/features.py

@@ -3115,6 +3115,28 @@ def delete_share(self) -> None:
         )
 
 
+class IPv6(AzureFeatureMixin, features.IPv6):
+    @classmethod
+    def create_setting(
+        cls, *args: Any, **kwargs: Any
+    ) -> Optional[schema.FeatureSettings]:
+        return schema.FeatureSettings.create(cls.name())
+
+    @classmethod
+    def on_before_deployment(cls, *args: Any, **kwargs: Any) -> None:
+        arm_parameters = cast(AzureArmParameter, kwargs.get("arm_parameters"))
+        # Enable IPv6 support in ARM template when IPv6 feature is required
+        # This ensures IPv6 is enabled during initial deployment and
+        # the setting persists for environment reuse scenarios
+        arm_parameters.use_ipv6 = True
+
+    def enabled(self) -> bool:
+        return True
+
+    def _initialize(self, *args: Any, **kwargs: Any) -> None:
+        super()._initialize(*args, **kwargs)
+
+
 class AzureExtension(AzureFeatureMixin, Feature):
     RESOURCE_NOT_FOUND = re.compile(r"ResourceNotFound", re.M)
 

lisa/sut_orchestrator/azure/platform_.py

@@ -500,6 +500,7 @@ def supported_features(cls) -> List[Type[feature.Feature]]:
             features.Nfs,
             features.Availability,
             features.Infiniband,
+            features.IPv6,
             features.Hibernation,
         ]
 

lisa/tools/ip.py

@@ -12,7 +12,7 @@
 from lisa.tools import Cat
 from lisa.tools.start_configuration import StartConfiguration
 from lisa.tools.whoami import Whoami
-from lisa.util import LisaException, find_patterns_in_lines
+from lisa.util import LisaException, find_patterns_in_lines, get_matched_str
 
 
 class IpInfo:
@@ -346,6 +346,20 @@ def get_ip_address(self, nic_name: str) -> str:
         assert "ip_addr" in matched, f"not find ip address for nic {nic_name}"
         return matched["ip_addr"]
 
+    def get_ipv6_address(self, nic_name: str) -> str:
+        """Get the global IPv6 address for a network interface."""
+        result = self.run(f"-6 addr show {nic_name}", force_run=True, sudo=True)
+
+        # Regex to match IPv6 addresses with global scope
+        # Example: inet6 2001:db8::5/128 scope global dynamic noprefixroute
+        ipv6_pattern = re.compile(r"inet6\s+([0-9a-fA-F:]+)\/\d+\s+scope\s+global")
+
+        ipv6_address = get_matched_str(result.stdout, ipv6_pattern)
+        if ipv6_address:
+            return ipv6_address
+
+        raise LisaException(f"No global IPv6 address found on interface {nic_name}")
+
     def get_default_route_info(self) -> tuple[str, str]:
         result = self.run("route", force_run=True, sudo=True)
         result.assert_exit_code()

lisa/tools/lagscope.py

@@ -131,14 +131,17 @@ def restore_busy_poll(self) -> None:
         for key in self._busy_pool_keys:
             sysctl.write(key, self._original_settings[key])
 
-    def run_as_server_async(self, ip: str = "") -> Process:
+    def run_as_server_async(self, ip: str = "", use_ipv6: bool = False) -> Process:
         # -r: run as a receiver
         # -rip: run as server mode with specified ip address
         cmd = ""
+        if use_ipv6:
+            cmd += " -6"
         if ip:
             cmd += f" -r{ip}"
         else:
             cmd += " -r"
+
         process = self.run_async(cmd, sudo=True, shell=True, force_run=True)
         if not process.is_running():
             raise LisaException("lagscope server failed to start")
@@ -159,6 +162,7 @@ def run_as_client_async(
         count_of_histogram_intervals: int = 30,
         dump_csv: bool = True,
         daemon: bool = False,
+        use_ipv6: bool = False,
     ) -> Process:
         # -s: run as a sender
         # -i: test interval
@@ -172,6 +176,8 @@ def run_as_client_async(
         # -R: dumps raw latencies into csv file
         # -D: run as daemon
         cmd = f"{self.command} -s{server_ip} "
+        if use_ipv6:
+            cmd += " -6 "
         if run_time_seconds:
             cmd += f" -t{run_time_seconds} "
         if count_of_histogram_intervals:
@@ -391,7 +397,7 @@ def restore_busy_poll(self) -> None:
         # This is not supported on FreeBSD.
         return
 
-    def run_as_server_async(self, ip: str = "") -> Process:
+    def run_as_server_async(self, ip: str = "", use_ipv6: bool = False) -> Process:
         return self.node.tools[Sockperf].start_server_async("tcp")
 
     def run_as_client_async(
@@ -407,6 +413,7 @@ def run_as_client_async(
         count_of_histogram_intervals: int = 30,
         dump_csv: bool = True,
         daemon: bool = False,
+        use_ipv6: bool = False,
     ) -> Process:
         return self.node.tools[Sockperf].run_client_async("tcp", server_ip)
 

lisa/tools/ntttcp.py

@@ -213,8 +213,11 @@ def run_as_server_async(
         dev_differentiator: str = "Hypervisor callback interrupts",
         run_as_daemon: bool = False,
         udp_mode: bool = False,
+        use_ipv6: bool = False,
     ) -> Process:
         cmd = ""
+        if use_ipv6:
+            cmd += " -6 "
         if server_ip:
             cmd += f" -r{server_ip} "
         cmd += (
@@ -308,6 +311,7 @@ def run_as_client(
         dev_differentiator: str = "Hypervisor callback interrupts",
         run_as_daemon: bool = False,
         udp_mode: bool = False,
+        use_ipv6: bool = False,
     ) -> ExecutableResult:
         # -sserver_ip: run as a sender with server ip address
         # -P: Number of ports listening on receiver side [default: 16] [max: 512]
@@ -326,11 +330,15 @@ def run_as_client(
         # the devices specified by the differentiator
         # Examples for differentiator: Hyper-V PCIe MSI, mlx4, Hypervisor callback
         # interrupts
-        cmd = (
+        cmd = ""
+        if use_ipv6:
+            cmd += " -6 "
+        cmd += (
             f" -s{server_ip} -P {ports_count} -n {threads_count} -t {run_time_seconds} "
             f"-W {warm_up_time_seconds} -C {cool_down_time_seconds} -b {buffer_size}k "
             f"--show-nic-packets {nic_name} "
         )
+
         if udp_mode:
             cmd += " -u "
         if dev_differentiator:

microsoft/testsuites/performance/common.py

@@ -32,6 +32,7 @@
     Fdisk,
     Fio,
     FIOResult,
+    Ip,
     Iperf3,
     Kill,
     Lagscope,
@@ -258,6 +259,7 @@ def perf_ntttcp(  # noqa: C901
     lagscope_server_ip: Optional[str] = None,
     server_nic_name: Optional[str] = None,
     client_nic_name: Optional[str] = None,
+    use_ipv6: bool = False,
 ) -> List[Union[NetworkTCPPerformanceMessage, NetworkUDPPerformanceMessage]]:
     # Either server and client are set explicitly or we use the first two nodes
     # from the environment. We never combine the two options. We need to specify
@@ -339,10 +341,23 @@ def perf_ntttcp(  # noqa: C901
                 client_nic_name if client_nic_name else client.nics.default_nic
             )
             dev_differentiator = "Hypervisor callback interrupts"
+
+        if use_ipv6:
+            # Retrieve IPv6 address of server, which is the address
+            # of the default nic.
+            server_ip_address = server.tools[Ip].get_ipv6_address(
+                server.nics.default_nic
+            )
+        else:
+            server_ip_address = server.internal_address
+
         server_lagscope.run_as_server_async(
-            ip=lagscope_server_ip
-            if lagscope_server_ip is not None
-            else server.internal_address
+            ip=(
+                lagscope_server_ip
+                if lagscope_server_ip is not None
+                else server_ip_address
+            ),
+            use_ipv6=use_ipv6,
         )
         max_server_threads = 64
         perf_ntttcp_message_list: List[
@@ -364,14 +379,15 @@ def perf_ntttcp(  # noqa: C901
 
             server_result = server_ntttcp.run_as_server_async(
                 server_nic_name,
-                server_ip=server.internal_address if isinstance(server.os, BSD) else "",
+                server_ip=server_ip_address if isinstance(server.os, BSD) else "",
                 ports_count=num_threads_p,
                 buffer_size=buffer_size,
                 dev_differentiator=dev_differentiator,
                 udp_mode=udp_mode,
+                use_ipv6=use_ipv6,
             )
             client_lagscope_process = client_lagscope.run_as_client_async(
-                server_ip=server.internal_address,
+                server_ip=server_ip_address,
                 ping_count=0,
                 run_time_seconds=10,
                 print_histogram=False,
@@ -380,15 +396,17 @@ def perf_ntttcp(  # noqa: C901
                 length_of_histogram_intervals=0,
                 count_of_histogram_intervals=0,
                 dump_csv=False,
+                use_ipv6=use_ipv6,
             )
             client_ntttcp_result = client_ntttcp.run_as_client(
                 client_nic_name,
-                server.internal_address,
+                server_ip_address,
                 buffer_size=buffer_size,
                 threads_count=num_threads_n,
                 ports_count=num_threads_p,
                 dev_differentiator=dev_differentiator,
                 udp_mode=udp_mode,
+                use_ipv6=use_ipv6,
             )
             server.tools[Kill].by_name(server_ntttcp.command)
             server_ntttcp_result = server_result.wait_result()

microsoft/testsuites/performance/networkperf.py

@@ -14,7 +14,7 @@
     simple_requirement,
 )
 from lisa.environment import Environment, Node
-from lisa.features import Sriov, Synthetic
+from lisa.features import IPv6, Sriov, Synthetic
 from lisa.operating_system import BSD, Windows
 from lisa.testsuite import TestResult
 from lisa.tools import Sysctl
@@ -286,6 +286,38 @@ def perf_udp_iperf_sriov(self, result: TestResult) -> None:
             udp_mode=True,
         )
 
+    @TestCaseMetadata(
+        description="""
+        This test case uses ntttcp to test IPv6 SR-IOV network throughput.
+        """,
+        priority=3,
+        timeout=TIMEOUT,
+        requirement=simple_requirement(
+            min_count=2,
+            network_interface=Sriov(),
+            supported_features=[IPv6],
+            unsupported_os=[BSD, Windows],
+        ),
+    )
+    def perf_tcp_ipv6_ntttcp_sriov(self, result: TestResult) -> None:
+        perf_ntttcp(result, use_ipv6=True)
+
+    @TestCaseMetadata(
+        description="""
+        This test case uses ntttcp to test IPv6 synthetic network throughput.
+        """,
+        priority=3,
+        timeout=TIMEOUT,
+        requirement=simple_requirement(
+            min_count=2,
+            network_interface=Synthetic(),
+            supported_features=[IPv6],
+            unsupported_os=[BSD, Windows],
+        ),
+    )
+    def perf_tcp_ipv6_ntttcp_synthetic(self, result: TestResult) -> None:
+        perf_ntttcp(result, use_ipv6=True)
+
     # Marked all following tests to skip on BSD since
     # sockperf compilation is not natively supported at this time
     # This is due to the default compiler on freebsd being c++17