resources/libraries/python/DMAUtil.py

   1 # Copyright (c) 2024 Intel and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """DMA util library."""
  15
  16 from re import search
  17 from resources.libraries.python.topology import NodeType, Topology
  18 from resources.libraries.python.ssh import exec_cmd, exec_cmd_no_error
  19
  20
  21 class DMAUtil:
  22     """Common DMA utilities"""
  23
  24     @staticmethod
  25     def get_dma_resource(node, dma_device):
  26         """Get DMA resource from DMA device.
  27
  28         :param node: Topology node.
  29         :param dma_device: DMA device.
  30         :type node: dict
  31         :type dma_device: str
  32         :returns: DMA resource.
  33         :rtype: dict
  34         """
  35
  36         cmd = f"grep -H . /sys/bus/pci/devices/{dma_device}/dsa*/*"
  37         _, stdout, stderr = exec_cmd(node, cmd, sudo=True)
  38
  39         dma_info = dict()
  40         dma_info["dma_device"] = dma_device
  41         dma_info["engine"] = list()
  42         dma_info["wq"] = list()
  43         dma_info["group"] = list()
  44
  45         for line in stdout.split():
  46             g1 = search(r"/(dsa\d+)/(.+):(.+)", line)
  47             if g1 is not None:
  48                 dma_info["dma_name"] = g1.group(1)
  49                 dma_info[f"{g1.group(2)}"] = g1.group(3)
  50
  51         for line in stderr.split():
  52             g2 = search(r"/(dsa\d+)/((engine|group|wq)\d+\.\d+)", line)
  53             if g2 is not None:
  54                 dev_type = g2.group(3)
  55                 dev = g2.group(2)
  56                 dma_info[dev_type].append(dev)
  57
  58         return dma_info
  59
  60     @staticmethod
  61     def disable_dma_device(node, dma_name):
  62         """Disable DMA device.
  63
  64         :param node: Topology node.
  65         :param dma_name: DMA name.
  66         :type node: dict
  67         :type dma_name: str
  68         """
  69         cmd = f"cat /sys/bus/dsa/devices/{dma_name}/state"
  70         stdout, _ = exec_cmd_no_error(
  71                 node, cmd, sudo=True,
  72                 message="Failed to get dma state.")
  73         if stdout.strip() == "disabled":
  74             return
  75
  76         cmd = f"accel-config disable-device -f {dma_name}"
  77         exec_cmd_no_error(
  78             node, cmd, sudo=True,
  79             message="Failed to disable DMA on DUT.")
  80
  81     @staticmethod
  82     def enable_dma_device(node, dma_name, groups, engines, wqs, wq_size,
  83             max_batch_size, max_transfer_size):
  84         """Enable DMA device.
  85
  86         :param node: Topology node.
  87         :param dma_name: DMA name.
  88         :param groups: DMA groups.
  89         :param engines: DMA engines.
  90         :param wqs: DMA work queues.
  91         :param wq_size: DMA work queue size.
  92         :param max_batch_size: Wq max batch size.
  93         :param max_transfer_size: Wq max transfer size.
  94         :type node: dict
  95         :type dma_name: str
  96         :type groups: list
  97         :type engines: list
  98         :type wqs: list
  99         :type wq_size: int
 100         :type max_batch_size: int
 101         :type max_transfer_size: int
 102         """
 103
 104         # Configure Device
 105         cmd = f"accel-config config-device {dma_name}"
 106
 107         exec_cmd_no_error(
 108             node, cmd, sudo=True,
 109             message="Failed to configure DMA device on DUT.")
 110
 111         # Configure DMA group
 112         for i, group in enumerate(groups):
 113             cmd = f"accel-config config-group " \
 114                     f"{dma_name}/{group} --read-buffers-reserved=0"
 115
 116             exec_cmd_no_error(
 117                 node, cmd, sudo=True,
 118                 message="Failed to configure DMA group on DUT.")
 119
 120         # Configure DMA engine
 121         for i, engine in enumerate(engines):
 122             cmd = f"accel-config config-engine " \
 123                     f"{dma_name}/{engine} --group-id={i}"
 124
 125             exec_cmd_no_error(
 126                 node, cmd, sudo=True,
 127                 message="Failed to configure DMA engine on DUT.")
 128
 129         # Configure DMA work queue
 130         for i, wq in enumerate(wqs):
 131             cmd = f"accel-config config-wq {dma_name}/{wq} " \
 132                 f" --group-id={i%len(engines)} --type=user " \
 133                 f" --priority=10 --block-on-fault=1 " \
 134                 f" --wq-size={wq_size} --mode=dedicated " \
 135                 f" --name={dma_name}_{i} " \
 136                 f" --max-batch-size={max_batch_size} " \
 137                 f" --max-transfer-size={max_transfer_size} "
 138
 139             exec_cmd_no_error(
 140                 node, cmd, sudo=True,
 141                 message="Failed to configure DMA work queue on DUT.")
 142
 143         # Enable DMA and work queues
 144         cmd = f"accel-config enable-device {dma_name}"
 145         exec_cmd_no_error(
 146             node, cmd, sudo=True,
 147             message="Failed to enable DMA device on DUT.")
 148
 149         dma_wqs = [f"{dma_name}/{wq}" for wq in wqs]
 150         cmd = f"accel-config enable-wq {' '.join(dma_wqs)}"
 151         exec_cmd_no_error(
 152             node, cmd, sudo=True,
 153             message="Failed to enable DMA work queue on DUT.")
 154
 155     @staticmethod
 156     def enable_dmas_and_wqs_on_dut(node, wq_num):
 157         """Enable DMAs and work queues on DUT.
 158
 159         :param node: Topology node.
 160         :param wq_num: Number of work queues.
 161         :type node: dict
 162         :type wq_num: int
 163         :returns: DMA work queues enabled.
 164         :rtype: list
 165         """
 166         if node["type"] == NodeType.DUT:
 167             dma_devs = Topology.get_bus(node)
 168
 169         enabled_wqs = list()
 170
 171         for dev in dma_devs.values():
 172             if "Intel-DSA" not in dev["model"]:
 173                 continue
 174
 175             dev_pci = dev["pci_address"]
 176             dma_info = DMAUtil.get_dma_resource(node, dev_pci)
 177
 178             dma_name = dma_info["dma_name"]
 179             groups = dma_info["group"]
 180             engines = dma_info["engine"]
 181             wqs = dma_info["wq"]
 182             wq_num_per_dma = wq_num//len(dma_devs) if wq_num > 1 else 1
 183             max_transfer_size = \
 184                     int(dma_info["max_transfer_size"])//wq_num_per_dma
 185             wq_size = int(dma_info["max_work_queues_size"])//wq_num_per_dma
 186             max_batch_size = int(dma_info["max_batch_size"])
 187
 188             DMAUtil.disable_dma_device(node, dma_name)
 189
 190             DMAUtil.enable_dma_device(node,
 191                     dma_name,
 192                     groups[:wq_num_per_dma],
 193                     engines[:wq_num_per_dma],
 194                     wqs[:wq_num_per_dma],
 195                     wq_size,
 196                     max_batch_size,
 197                     max_transfer_size
 198                     )
 199             enabled_wqs += wqs[:wq_num_per_dma]
 200
 201             cmd = f"lspci -vvv -s {dev_pci}"
 202             exec_cmd_no_error(
 203                 node, cmd, sudo=True, message="Failed")
 204
 205         cmd = "accel-config list"
 206         exec_cmd_no_error(
 207             node, cmd, sudo=True, message="Failed")
 208
 209         cmd = "cat /proc/cmdline"
 210         exec_cmd_no_error(
 211             node, cmd, sudo=True, message="Failed")
 212
 213         return enabled_wqs