test/asf/test_node_variants.py

   1 #!/usr/bin/env python3
   2 import re
   3 import unittest
   4 import platform
   5 from asfframework import VppAsfTestCase
   6
   7
   8 def checkX86():
   9     return platform.machine() in ["x86_64", "AMD64", "amd64"]
  10
  11
  12 def skipVariant(variant):
  13     # TODO: We don't have cpu feature detection on FreeBSD yet, so always return
  14     # that we don't have the requested variant.
  15     if platform.uname().system == "FreeBSD":
  16         return False
  17
  18     with open("/proc/cpuinfo") as f:
  19         cpuinfo = f.read()
  20
  21     exp = re.compile(r"(?:flags\s+:)(?:\s\w+)+(?:\s(" + variant + r"))(?:\s\w+)+")
  22     match = exp.search(cpuinfo, re.DOTALL | re.MULTILINE)
  23
  24     return checkX86() and match is not None
  25
  26
  27 class TestNodeVariant(VppAsfTestCase):
  28     """Test Node Variants"""
  29
  30     @classmethod
  31     def setUpConstants(cls, variant):
  32         super(TestNodeVariant, cls).setUpConstants()
  33         # find the position of node_variants in the cmdline args.
  34
  35         if checkX86():
  36             node_variants = cls.vpp_cmdline.index("node { ") + 1
  37             cls.vpp_cmdline[node_variants] = (
  38                 "default { variant default } "
  39                 "ip4-rewrite { variant " + variant + " } "
  40             )
  41
  42     @classmethod
  43     def setUpClass(cls):
  44         super(TestNodeVariant, cls).setUpClass()
  45
  46     @classmethod
  47     def tearDownClass(cls):
  48         super(TestNodeVariant, cls).tearDownClass()
  49
  50     def setUp(self):
  51         super(TestNodeVariant, self).setUp()
  52
  53     def tearDown(self):
  54         super(TestNodeVariant, self).tearDown()
  55
  56     def getActiveVariant(self, node):
  57         node_desc = self.vapi.cli("show node " + node)
  58         self.logger.info(node_desc)
  59
  60         match = re.search(
  61             r"\s+(\S+)\s+(\d+)\s+(:?yes)", node_desc, re.DOTALL | re.MULTILINE
  62         )
  63
  64         return match.groups(0)
  65
  66     def checkVariant(self, variant):
  67         """Test node variants defaults"""
  68
  69         variant_info = self.getActiveVariant("ip4-lookup")
  70         self.assertEqual(variant_info[0], "default")
  71
  72         variant_info = self.getActiveVariant("ip4-rewrite")
  73         self.assertEqual(variant_info[0], variant)
  74
  75
  76 class TestICLVariant(TestNodeVariant):
  77     """Test icl Node Variants"""
  78
  79     VARIANT = "icl"
  80     LINUX_VARIANT = "avx512_bitalg"
  81
  82     @classmethod
  83     def setUpConstants(cls):
  84         super(TestICLVariant, cls).setUpConstants(cls.VARIANT)
  85
  86     @classmethod
  87     def setUpClass(cls):
  88         super(TestICLVariant, cls).setUpClass()
  89
  90     @classmethod
  91     def tearDownClass(cls):
  92         super(TestICLVariant, cls).tearDownClass()
  93
  94     @unittest.skipUnless(
  95         skipVariant(LINUX_VARIANT), VARIANT + " not a supported variant, skip."
  96     )
  97     def test_icl(self):
  98         self.checkVariant(self.VARIANT)
  99
 100
 101 class TestSKXVariant(TestNodeVariant):
 102     """Test skx Node Variants"""
 103
 104     VARIANT = "skx"
 105     LINUX_VARIANT = "avx512f"
 106
 107     @classmethod
 108     def setUpConstants(cls):
 109         super(TestSKXVariant, cls).setUpConstants(cls.VARIANT)
 110
 111     @classmethod
 112     def setUpClass(cls):
 113         super(TestSKXVariant, cls).setUpClass()
 114
 115     @classmethod
 116     def tearDownClass(cls):
 117         super(TestSKXVariant, cls).tearDownClass()
 118
 119     @unittest.skipUnless(
 120         skipVariant(LINUX_VARIANT), VARIANT + " not a supported variant, skip."
 121     )
 122     def test_skx(self):
 123         self.checkVariant(self.VARIANT)
 124
 125
 126 class TestHSWVariant(TestNodeVariant):
 127     """Test avx2 Node Variants"""
 128
 129     VARIANT = "hsw"
 130     LINUX_VARIANT = "avx2"
 131
 132     @classmethod
 133     def setUpConstants(cls):
 134         super(TestHSWVariant, cls).setUpConstants(cls.VARIANT)
 135
 136     @classmethod
 137     def setUpClass(cls):
 138         super(TestHSWVariant, cls).setUpClass()
 139
 140     @classmethod
 141     def tearDownClass(cls):
 142         super(TestHSWVariant, cls).tearDownClass()
 143
 144     @unittest.skipUnless(
 145         skipVariant(LINUX_VARIANT), VARIANT + " not a supported variant, skip."
 146     )
 147     def test_hsw(self):
 148         self.checkVariant(self.VARIANT)