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

Adam Miszczak
2026-02-24T08:24:22Z

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)]

@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'])
--
2.39.1