Re: [PATCH i-g-t 05/10] tools/vmtb: VF auto/fair provisioning support

Bernatowicz, Marcin
2026-03-10T10:39:02Z

On 2/24/2026 8:50 AM, Adam Miszczak wrote:
> Currently test variants allow provisioning with vGPU profiles only,
> however, xe KMD supports also fair resources allocation (auto-provisioning).
> Therefore, the following provisioning modes shall be supported from now:
> - vGPU profile: both PF/VF resources and scheduling (via debugfs)
> - fair/auto provisioning (driver defaults for resources and scheduling)
> - fair/auto resources provisioning with concrete scheduling profile
>
> Test variants are now specified as a list of 3-element tuples:
> test_variants_N = [(num_of_vfs, VfProvisioningMode.X, VfSchedulingMode.Y), ...]
> Test ID printed in the following format:
> test_name[NxVF-(P:provisioning_mode S:scheduling_mode)]
>
> Additional changes:
> - align parametrized tests with the new variants format
> - use Device methods: set_resources and set_scheduling
> for relevant provisioning modes
> - split vGPU profile printing to resources and scheduler part
> - fix PF lmem_spare getter/setter to check for LMEM presence
> - detect standalone media GT for proper VF provisioning
>
> Signed-off-by: Adam Miszczak <adam.miszczak@linux.intel.com>
> ---
> .../vmtb/bench/configurators/vgpu_profile.py | 37 +++++---
> .../configurators/vgpu_profile_config.py | 7 +-
> tools/vmtb/bench/drivers/driver_interface.py | 6 +-
> tools/vmtb/bench/drivers/xe.py | 16 +++-
> tools/vmtb/bench/machines/physical/device.py | 58 +++++++-----
> tools/vmtb/vmm_flows/conftest.py | 89 ++++++++++++++-----
> tools/vmtb/vmm_flows/test_basic.py | 21 +++--
> 7 files changed, 164 insertions(+), 70 deletions(-)
>
> diff --git a/tools/vmtb/bench/configurators/vgpu_profile.py b/tools/vmtb/bench/configurators/vgpu_profile.py
> index 7c536c1d0..c680fdb83 100644
> --- a/tools/vmtb/bench/configurators/vgpu_profile.py
> +++ b/tools/vmtb/bench/configurators/vgpu_profile.py
> @@ -1,5 +1,5 @@
> # SPDX-License-Identifier: MIT
> -# Copyright © 2024 Intel Corporation
> +# Copyright © 2024-2026 Intel Corporation
>
> import json
> import logging
> @@ -55,8 +55,19 @@ class VgpuProfile:
> def print_parameters(self) -> None:
> logger.info(
> "\nvGPU Profile:\n"
> - " Num VFs = %s\n"
> - "\nResources:\n"
> + " Num VFs = %s\n",
> + self.num_vfs)
> + self.print_resources_config()
> + self.print_scheduler_config()
> + logger.info(
> + "\nSecurity:\n"
> + " Reset After Vf Switch = %s\n",
> + self.security.reset_after_vf_switch
> + )
> +
> + def print_resources_config(self) -> None:
> + logger.info(
> + "\nResources config:\n"
> " PF:\n"
> "\tLMEM = %s B\n"
> "\tContexts = %s\n"
> @@ -66,24 +77,24 @@ class VgpuProfile:
> "\tLMEM = %s B\n"
> "\tContexts = %s\n"
> "\tDoorbells = %s\n"
> - "\tGGTT = %s B\n"
> - "\nScheduling:\n"
> + "\tGGTT = %s B\n",
> + self.resources.pfLmem, self.resources.pfContexts, self.resources.pfDoorbells, self.resources.pfGgtt,
> + self.resources.vfLmem, self.resources.vfContexts, self.resources.vfDoorbells, self.resources.vfGgtt,
> + )
> +
> + def print_scheduler_config(self) -> None:
> + logger.info(
> + "\nScheduling config:\n"
> " Schedule If Idle = %s\n"
> " PF:\n"
> "\tExecution Quanta = %s ms\n"
> "\tPreemption Timeout = %s us\n"
> " VF:\n"
> "\tExecution Quanta = %s ms\n"
> - "\tPreemption Timeout = %s us\n"
> - "\nSecurity:\n"
> - " Reset After Vf Switch = %s\n",
> - self.num_vfs,
> - self.resources.pfLmem, self.resources.pfContexts, self.resources.pfDoorbells, self.resources.pfGgtt,
> - self.resources.vfLmem, self.resources.vfContexts, self.resources.vfDoorbells, self.resources.vfGgtt,
> + "\tPreemption Timeout = %s us\n",
> self.scheduler.scheduleIfIdle,
> self.scheduler.pfExecutionQuanta, self.scheduler.pfPreemptionTimeout,
> - self.scheduler.vfExecutionQuanta, self.scheduler.vfPreemptionTimeout,
> - self.security.reset_after_vf_switch
> + self.scheduler.vfExecutionQuanta, self.scheduler.vfPreemptionTimeout
> )
>
>
> diff --git a/tools/vmtb/bench/configurators/vgpu_profile_config.py b/tools/vmtb/bench/configurators/vgpu_profile_config.py
> index 915cfb2b8..4bddb641e 100644
> --- a/tools/vmtb/bench/configurators/vgpu_profile_config.py
> +++ b/tools/vmtb/bench/configurators/vgpu_profile_config.py
> @@ -1,5 +1,5 @@
> # SPDX-License-Identifier: MIT
> -# Copyright © 2024 Intel Corporation
> +# Copyright © 2024-2026 Intel Corporation
>
> import logging
> from enum import Enum
> @@ -17,6 +17,11 @@ from bench.configurators.vgpu_profile import (VgpuProfile,
> logger = logging.getLogger('DeviceConfigurator')
>
>
> +class VfProvisioningMode(Enum):
> + VGPU_PROFILE = 0
> + AUTO = 1
> +
> +
> class VfSchedulingMode(str, Enum):
> INFINITE = 'Infinite' # Infinite EQ/PT - HW default
> DEFAULT_PROFILE = 'Default_Profile' # Default vGPU scheduler profile
> diff --git a/tools/vmtb/bench/drivers/driver_interface.py b/tools/vmtb/bench/drivers/driver_interface.py
> index af2f96837..3026fece7 100644
> --- a/tools/vmtb/bench/drivers/driver_interface.py
> +++ b/tools/vmtb/bench/drivers/driver_interface.py
> @@ -1,5 +1,5 @@
> # SPDX-License-Identifier: MIT
> -# Copyright © 2024 Intel Corporation
> +# Copyright © 2024-2026 Intel Corporation
>
> import abc
> import enum
> @@ -65,6 +65,10 @@ class DriverInterface(abc.ABC):
> def has_lmem(self) -> bool:
> raise NotImplementedError
>
> + @abc.abstractmethod
> + def is_media_gt(self, gt_num: int) -> bool:
> + raise NotImplementedError
> +
> @abc.abstractmethod
> def get_auto_provisioning(self) -> bool:
> raise NotImplementedError
> diff --git a/tools/vmtb/bench/drivers/xe.py b/tools/vmtb/bench/drivers/xe.py
> index 009cec5be..c2b9643bb 100644
> --- a/tools/vmtb/bench/drivers/xe.py
> +++ b/tools/vmtb/bench/drivers/xe.py
> @@ -1,5 +1,5 @@
> # SPDX-License-Identifier: MIT
> -# Copyright © 2024 Intel Corporation
> +# Copyright © 2024-2026 Intel Corporation
>
> import logging
> import typing
> @@ -95,11 +95,18 @@ class XeDriver(DriverInterface):
> path = self.debugfs_path / 'gt0' / 'pf' / 'lmem_spare'
> return path.exists()
>
> + def is_media_gt(self, gt_num: int) -> bool:
> + # XXX: is lack of PF's ggtt/lmem_spare or VF's ggtt/lmem_quota
> + # a best way to check for standalone media GT?
> + path = self.debugfs_path / f'gt{gt_num}' / 'pf' / 'ggtt_spare'
> + return not path.exists()
> +
> def get_auto_provisioning(self) -> bool:
> raise exceptions.NotAvailableError('auto_provisioning attribute not available')
>
> def set_auto_provisioning(self, val: bool) -> None:
> - raise exceptions.NotAvailableError('auto_provisioning attribute not available')
> + # No-op - xe driver doesn't publish this attribute
> + pass
>
> def cancel_work(self) -> None:
> # Function to cancel all remaing work on GPU (for test cleanup).
> @@ -129,11 +136,12 @@ class XeDriver(DriverInterface):
>
> def get_pf_lmem_spare(self, gt_num: int) -> int:
> path = self.__helper_create_debugfs_path(0, gt_num, '', 'lmem_spare')
> - return int(self.__read_debugfs(path))
> + return int(self.__read_debugfs(path)) if self.has_lmem() else 0
>
> def set_pf_lmem_spare(self, gt_num: int, val: int) -> None:
> path = self.__helper_create_debugfs_path(0, gt_num, '', 'lmem_spare')
> - self.__write_debugfs(path, str(val))
> + if self.has_lmem():
> + self.__write_debugfs(path, str(val))
>
> def get_pf_contexts_spare(self, gt_num: int) -> int:
> path = self.__helper_create_debugfs_path(0, gt_num, '', 'contexts_spare')
> diff --git a/tools/vmtb/bench/machines/physical/device.py b/tools/vmtb/bench/machines/physical/device.py
> index a487c0e5f..250466733 100644
> --- a/tools/vmtb/bench/machines/physical/device.py
> +++ b/tools/vmtb/bench/machines/physical/device.py
> @@ -83,6 +83,9 @@ class Device(DeviceInterface):
> def has_lmem(self) -> bool:
> return self.driver.has_lmem()
>
> + def is_gt_media_type(self, gt_num: int) -> bool:
> + return self.driver.is_media_gt(gt_num)
> +
> def create_vf(self, num: int) -> int:
> """Enable a requested number of VFs.
> Disable SRIOV drivers autoprobe to allow VFIO driver override for VFs.
> @@ -156,37 +159,44 @@ class Device(DeviceInterface):
> bdf_list = [self.get_vf_bdf(vf) for vf in vf_list]
> return bdf_list
>
> - def provision(self, profile: VgpuProfile) -> None:
> - logger.info("[%s] Provision VFs - set vGPU profile for %s VFs", self.pci_info.bdf, profile.num_vfs)
> + def __set_provisioning(self, num_vfs: int, profile: VgpuProfile, set_resources: bool) -> None:
> + """Helper to write provisioning attributes over sysfs/debugfs for PF and requested number of VFs.
> + If 'set_resources' parameter is True - apply the full vGPU profile (hard resources and scheduling).
> + Otherwise, set only scheduling profile (e.g. in case of auto resources provisioning).
> + """
> + main_gt_nums = [gt_num for gt_num in range(self.get_num_gts()) if not self.is_gt_media_type(gt_num)]
>
> - num_vfs = profile.num_vfs
> - num_gts = self.get_num_gts() # Number of tiles (GTs)
> - gt_nums = [0] if num_gts == 1 else [0, 1] # Tile (GT) numbers/indexes
> + logger.info("[%s] Provision %sxVFs on main GT%s", self.pci_info.bdf, num_vfs, main_gt_nums)
>
> - for gt_num in gt_nums:
> - self.driver.set_pf_policy_sched_if_idle(gt_num, int(profile.scheduler.scheduleIfIdle))
> + for gt_num in main_gt_nums:
> + if set_resources:
> + self.set_resources(0, gt_num, profile.resources)
> + self.set_scheduling(0, gt_num, profile.scheduler)
> self.driver.set_pf_policy_reset_engine(gt_num, int(profile.security.reset_after_vf_switch))
> - self.driver.set_exec_quantum_ms(0, gt_num, profile.scheduler.pfExecutionQuanta)
> - self.driver.set_preempt_timeout_us(0, gt_num, profile.scheduler.pfPreemptionTimeout)
> - self.driver.set_doorbells_quota(0, gt_num, profile.resources.pfDoorbells)
> - # PF contexts are currently assigned by the driver and cannot be reprovisioned from sysfs
>
> for vf_num in range(1, num_vfs + 1):
> - if num_gts > 1 and num_vfs > 1:
> + gt_nums = main_gt_nums
> + if len(main_gt_nums) > 1 and num_vfs > 1:
> # Multi-tile device Mode 2|3 - odd VFs on GT0, even on GT1
> - gt_nums = [0] if vf_num % 2 else [1]
> + gt_nums = [main_gt_nums[0] if vf_num % 2 else main_gt_nums[1]]
>
> for gt_num in gt_nums:
> - self.driver.set_lmem_quota(vf_num, gt_num, profile.resources.vfLmem)
> - self.driver.set_ggtt_quota(vf_num, gt_num, profile.resources.vfGgtt)
> - self.driver.set_contexts_quota(vf_num, gt_num, profile.resources.vfContexts)
> - self.driver.set_doorbells_quota(vf_num, gt_num, profile.resources.vfDoorbells)
> - self.driver.set_exec_quantum_ms(vf_num, gt_num, profile.scheduler.vfExecutionQuanta)
> - self.driver.set_preempt_timeout_us(vf_num, gt_num, profile.scheduler.vfPreemptionTimeout)
> + if set_resources:
> + self.set_resources(vf_num, gt_num, profile.resources)
> + self.set_scheduling(vf_num, gt_num, profile.scheduler)
> +
> + def provision(self, profile: VgpuProfile) -> None:
> + """Provision PF and VF(s) based on requested vGPU profile."""
> + self.__set_provisioning(profile.num_vfs, profile, set_resources=True)
> +
> + def provision_scheduling(self, num_vfs: int, profile: VgpuProfile) -> None:
> + """Provision PF and VF(s) scheduling based on requested vGPU profile's scheduler config."""
> + self.__set_provisioning(num_vfs, profile, set_resources=False)
>
> # fn_num = 0 for PF, 1..n for VF
> def set_scheduling(self, fn_num: int, gt_num: int, scheduling_config: VgpuSchedulerConfig) -> None:
> - logger.info("[%s] Provision scheduling config for PCI Function %s", self.pci_info.bdf, fn_num)
> + """Write sysfs/debugfs PF/VF scheduling attributes."""
> + logger.debug("[%s] Set scheduling for PCI Function %s", self.pci_info.bdf, fn_num)
> if fn_num == 0:
> self.driver.set_pf_policy_sched_if_idle(gt_num, int(scheduling_config.scheduleIfIdle))
> self.driver.set_exec_quantum_ms(0, gt_num, scheduling_config.pfExecutionQuanta)
> @@ -196,7 +206,8 @@ class Device(DeviceInterface):
> self.driver.set_preempt_timeout_us(fn_num, gt_num, scheduling_config.vfPreemptionTimeout)
>
> def set_resources(self, fn_num: int, gt_num: int, resources_config: VgpuResourcesConfig) -> None:
> - logger.info("[%s] Provision resources config for PCI Function %s", self.pci_info.bdf, fn_num)
> + """Write sysfs/debugfs PF/VF resources attributes."""
> + logger.debug("[%s] Set resources for PCI Function %s", self.pci_info.bdf, fn_num)
> if fn_num == 0:
> self.driver.set_pf_ggtt_spare(gt_num, resources_config.pfGgtt)
> self.driver.set_pf_lmem_spare(gt_num, resources_config.pfLmem)
> @@ -227,8 +238,9 @@ class Device(DeviceInterface):
> for vf_num in range(1, num_vfs + 1):
> self.driver.set_contexts_quota(vf_num, gt_num, 0)
> self.driver.set_doorbells_quota(vf_num, gt_num, 0)
> - self.driver.set_ggtt_quota(vf_num, gt_num, 0)
> - self.driver.set_lmem_quota(vf_num, gt_num, 0)
> + if not self.is_gt_media_type(gt_num):
> + self.driver.set_ggtt_quota(vf_num, gt_num, 0)
> + self.driver.set_lmem_quota(vf_num, gt_num, 0)
>
> def cancel_work(self) -> None:
> """Drop and reset remaining GPU execution at exit."""
> diff --git a/tools/vmtb/vmm_flows/conftest.py b/tools/vmtb/vmm_flows/conftest.py
> index 28c0b5f00..12726416f 100644
> --- a/tools/vmtb/vmm_flows/conftest.py
> +++ b/tools/vmtb/vmm_flows/conftest.py
> @@ -12,7 +12,8 @@ import pytest
>
> from bench import exceptions
> from bench.configurators.vgpu_profile import VgpuProfile
> -from bench.configurators.vgpu_profile_config import (VfSchedulingMode,
> +from bench.configurators.vgpu_profile_config import (VfProvisioningMode,
> + VfSchedulingMode,
> VgpuProfileConfigurator)
> from bench.configurators.vmtb_config import VmtbConfigurator
> from bench.helpers.helpers import modprobe_driver, modprobe_driver_check
> @@ -39,6 +40,7 @@ class VmmTestingConfig:
> Available settings:
> - num_vfs: requested number of VFs to enable
> - max_num_vms: maximal number of VMs (the value can be different than enabled number of VFs)
> + - provisioning_mode: auto (fair resources allocation by a driver) or vGPU profile
> - scheduling_mode: requested vGPU scheduling profile (infinite maps to default 0's)
> - auto_poweron_vm: assign VFs and power on VMs automatically in setup fixture
> - auto_probe_vm_driver: probe guest DRM driver in setup fixture (VM must be powered on)
> @@ -47,6 +49,7 @@ class VmmTestingConfig:
> """
> num_vfs: int = 1
> max_num_vms: int = 2
> + provisioning_mode: VfProvisioningMode = VfProvisioningMode.AUTO
> scheduling_mode: VfSchedulingMode = VfSchedulingMode.INFINITE
>
> auto_poweron_vm: bool = True
> @@ -56,12 +59,14 @@ class VmmTestingConfig:
> wa_reduce_vf_lmem: bool = False
>
> def __str__(self) -> str:
> - return f'{self.num_vfs}VF'
> + test_config_id = f'{self.num_vfs}VF-(P:{self.provisioning_mode.name} S:{self.scheduling_mode.name})'
> + return test_config_id
>
> def __repr__(self) -> str:
> return (f'\nVmmTestingConfig:'
> f'\nNum VFs = {self.num_vfs} / max num VMs = {self.max_num_vms}'
> - f'\nVF scheduling mode = {self.scheduling_mode}'
> + f'\nVF provisioning mode = {self.provisioning_mode.name}'
> + f'\nVF scheduling mode = {self.scheduling_mode.name}'
> f'\nSetup flags:'
> f'\n\tVM - auto power-on = {self.auto_poweron_vm}'
> f'\n\tVM - auto DRM driver probe = {self.auto_probe_vm_driver}'
> @@ -107,7 +112,9 @@ class VmmTestingSetup:
> # [vmtb_root]/vmm_flows/resources/wsim/ptl (last subdir is lowercase key/name from pci.GpuModel class)
> self.wsim_wl_dir = vmtb_root_path / vmtb_config.config.wsim_wl_path / self.get_dut().gpu_model.name.lower()
>
> - self.vgpu_profile: VgpuProfile = self.get_vgpu_profile()
> + if (self.testing_config.provisioning_mode is VfProvisioningMode.VGPU_PROFILE
> + or self.testing_config.scheduling_mode is not VfSchedulingMode.INFINITE):
> + self.vgpu_profile: VgpuProfile = self.get_vgpu_profile()
>
> # Start maximum requested number of VMs, but not more than VFs supported by the given vGPU profile
> self.vms: typing.List[VirtualMachine] = [
> @@ -115,7 +122,7 @@ class VmmTestingSetup:
> vmtb_config.get_guest_config().driver,
> vmtb_config.get_guest_config().igt_config,
> vf_migration_support)
> - for vm_idx in range(min(self.vgpu_profile.num_vfs, self.testing_config.max_num_vms))]
> + for vm_idx in range(min(self.testing_config.num_vfs, self.testing_config.max_num_vms))]
>
> def get_vgpu_profile(self) -> VgpuProfile:
> configurator = VgpuProfileConfigurator(self.vgpu_profiles_dir, self.get_dut().gpu_model)
> @@ -126,8 +133,6 @@ class VmmTestingSetup:
> logger.error("Suitable vGPU profile not found: %s", exc)
> raise exceptions.VgpuProfileError('Invalid test setup - vGPU profile not found!')
>
> - vgpu_profile.print_parameters()
> -
> return vgpu_profile
>
> def get_dut(self) -> Device:
> @@ -224,20 +229,35 @@ def fixture_setup_vms(get_vmtb_config, get_cmdline_config, get_host, request):
> ts: VmmTestingSetup = VmmTestingSetup(get_vmtb_config, get_cmdline_config, host, tc)
>
> device: Device = ts.get_dut()
> - num_vfs = ts.vgpu_profile.num_vfs
> + num_vfs = ts.testing_config.num_vfs
> num_vms = ts.get_num_vms()
>
> logger.info('[Test setup: %sVF-%sVM]', num_vfs, num_vms)
>
> - # XXX: VF migration on discrete devices (with LMEM) is currently quite slow.
> - # As a temporary workaround, reduce size of LMEM assigned to VFs to speed up a state save/load process.
> - if tc.wa_reduce_vf_lmem and device.has_lmem():
> - logger.debug("W/A: reduce VFs LMEM quota to accelerate state save/restore")
> - org_vgpu_profile_vfLmem = ts.vgpu_profile.resources.vfLmem
> - # Assign max 512 MB to VF
> - ts.vgpu_profile.resources.vfLmem = min(ts.vgpu_profile.resources.vfLmem // 2, 536870912)
> -
> - device.provision(ts.vgpu_profile)
> + if ts.testing_config.provisioning_mode is VfProvisioningMode.VGPU_PROFILE:
> + # XXX: Double migration is slow on discrete GPUs (with VRAM),
> + # As a workaround, reduce VRAM size assigned to VFs to speed up a save process.
> + # This w/a should be removed when a save/restore time improves.
> + if tc.wa_reduce_vf_lmem and device.has_lmem():
> + logger.debug("W/A: reduce VFs LMEM quota to accelerate state save")
> + org_vgpu_profile_vfLmem = ts.vgpu_profile.resources.vfLmem
> + # Assign max 512 MB to VF
> + ts.vgpu_profile.resources.vfLmem = min(ts.vgpu_profile.resources.vfLmem // 2, 536870912)
> +
> + ts.vgpu_profile.print_parameters()
> + device.provision(ts.vgpu_profile)
> +
> + # XXX: cleanup counterpart for VFs LMEM quota workaround:
> + # restore original value after vGPU profile applied
> + if tc.wa_reduce_vf_lmem and device.has_lmem():
> + ts.vgpu_profile.resources.vfLmem = org_vgpu_profile_vfLmem
> +
> + else:
> + device.driver.set_auto_provisioning(True)
> + if ts.testing_config.scheduling_mode is not VfSchedulingMode.INFINITE:
> + # Auto provisioning with concrete scheduling (i.e. different than HW default: infinite)
> + ts.vgpu_profile.print_scheduler_config()
> + device.provision_scheduling(num_vfs, ts.vgpu_profile)
>
> assert device.create_vf(num_vfs) == num_vfs
>
> @@ -257,10 +277,39 @@ def fixture_setup_vms(get_vmtb_config, get_cmdline_config, get_host, request):
> yield ts
>
> logger.info('[Test teardown: %sVF-%sVM]', num_vfs, num_vms)
> - # XXX: cleanup counterpart for VFs LMEM quota workaround - restore original value
> - if tc.wa_reduce_vf_lmem and device.has_lmem():
> - ts.vgpu_profile.resources.vfLmem = org_vgpu_profile_vfLmem
> + ts.teardown()
>
> +
> +# Obsolete fixtures 'create_Xhost_Yvm' - 'fixture_setup_vms' is preferred
> +@pytest.fixture(scope='function')
> +def create_1host_1vm(get_vmtb_config, get_cmdline_config, get_host):
> + num_vfs, num_vms = 1, 1
> + ts: VmmTestingSetup = VmmTestingSetup(get_vmtb_config, get_cmdline_config, get_host,
> + VmmTestingConfig(num_vfs, num_vms))
> +
> + logger.info('[Test setup: %sVF-%sVM]', num_vfs, num_vms)
> + logger.debug(repr(ts.testing_config))
> +
> + logger.info('[Test execution: %sVF-%sVM]', num_vfs, num_vms)
> + yield ts
> +
> + logger.info('[Test teardown: %sVF-%sVM]', num_vfs, num_vms)
> + ts.teardown()
> +
> +
> +@pytest.fixture(scope='function')
> +def create_1host_2vm(get_vmtb_config, get_cmdline_config, get_host):
> + num_vfs, num_vms = 2, 2
> + ts: VmmTestingSetup = VmmTestingSetup(get_vmtb_config, get_cmdline_config, get_host,
> + VmmTestingConfig(num_vfs, num_vms))
> +
> + logger.info('[Test setup: %sVF-%sVM]', num_vfs, num_vms)
> + logger.debug(repr(ts.testing_config))
> +
> + logger.info('[Test execution: %sVF-%sVM]', num_vfs, num_vms)
> + yield ts
> +
> + logger.info('[Test teardown: %sVF-%sVM]', num_vfs, num_vms)
> ts.teardown()
>
>
> diff --git a/tools/vmtb/vmm_flows/test_basic.py b/tools/vmtb/vmm_flows/test_basic.py
> index 1d3a68b36..9b8731273 100644
> --- a/tools/vmtb/vmm_flows/test_basic.py
> +++ b/tools/vmtb/vmm_flows/test_basic.py
> @@ -7,7 +7,7 @@ from typing import List, Tuple
>
> import pytest
>
> -from bench.configurators.vgpu_profile_config import VfSchedulingMode
> +from bench.configurators.vgpu_profile_config import VfProvisioningMode, VfSchedulingMode
> from bench.executors.gem_wsim import (ONE_CYCLE_DURATION_MS,
> PREEMPT_10MS_WORKLOAD, GemWsim,
> GemWsimResult,
> @@ -27,20 +27,23 @@ DELAY_FOR_WORKLOAD_SEC = 2 # Waiting gem_wsim to be running [seconds]
> DELAY_FOR_RELOAD_SEC = 3 # Waiting before driver reloading [seconds]
>
>
> -def set_test_config(test_variants: List[Tuple[int, VfSchedulingMode]],
> +def set_test_config(test_variants: List[Tuple[int, VfProvisioningMode, VfSchedulingMode]],
> max_vms: int = 2, vf_driver_load: bool = True) -> List[VmmTestingConfig]:
> """Helper function to provide a parametrized test with a list of test configuration variants."""
> logger.debug("Init test variants: %s", test_variants)
> test_configs: List[VmmTestingConfig] = []
>
> for config in test_variants:
> - (num_vfs, scheduling_mode) = config
> - test_configs.append(VmmTestingConfig(num_vfs, max_vms, scheduling_mode, auto_probe_vm_driver=vf_driver_load))
> + (num_vfs, provisioning_mode, scheduling_mode) = config
> + test_configs.append(VmmTestingConfig(num_vfs, max_vms, provisioning_mode, scheduling_mode,
> + auto_probe_vm_driver=vf_driver_load))
>
> return test_configs
>
>
> -test_variants_1 = [(1, VfSchedulingMode.DEFAULT_PROFILE), (2, VfSchedulingMode.DEFAULT_PROFILE)]
> +test_variants_1 = [(1, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE),
> + (2, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE),
> + (2, VfProvisioningMode.AUTO, VfSchedulingMode.INFINITE)]
>
> @pytest.mark.parametrize('setup_vms', set_test_config(test_variants_1), ids=idfn_test_config, indirect=['setup_vms'])
> class TestVmSetup:
> @@ -60,8 +63,9 @@ class TestVmSetup:
> assert driver_check(vm)
>
>
> -test_variants_2 = [(1, VfSchedulingMode.DEFAULT_PROFILE), (2, VfSchedulingMode.DEFAULT_PROFILE),
> - (4, VfSchedulingMode.DEFAULT_PROFILE)]
> +test_variants_2 = [(1, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE),
> + (2, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE),
> + (4, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE)]
>
> @pytest.mark.parametrize('setup_vms', set_test_config(test_variants_2), ids=idfn_test_config, indirect=['setup_vms'])
> class TestVmWorkload:
> @@ -102,7 +106,8 @@ class TestVmWorkload:
> logger.info("Execute wsim parallel on VMs - results: %s", result)
>
>
> -test_variants_3 = [(2, VfSchedulingMode.DEFAULT_PROFILE), (4, VfSchedulingMode.DEFAULT_PROFILE)]
> +test_variants_3 = [(2, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE),
> + (4, VfProvisioningMode.VGPU_PROFILE, VfSchedulingMode.DEFAULT_PROFILE)]
LGTM,
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>
> @pytest.mark.parametrize('setup_vms', set_test_config(test_variants=test_variants_3, max_vms=4, vf_driver_load=False),
> ids = idfn_test_config, indirect=['setup_vms'])