def test_older_snapshot_resume_latency(bin_cloner_path, results_file_dumper):
"""
Test scenario: Older snapshot load performance measurement.
@type: performance
"""
logger = logging.getLogger("old_snapshot_load")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# With each binary create a snapshot and try to restore in current
# version.
firecracker_artifacts = ArtifactSet(artifacts.firecrackers(
max_version=get_firecracker_version_from_toml()))
assert len(firecracker_artifacts) > 0
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'snapshot_type': SnapshotType.FULL,
'name': 'old_snapshot_resume_latency',
'results_file_dumper': results_file_dumper
}
# Create the test matrix.
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
firecracker_artifacts,
microvm_artifacts,
])
test_matrix.run_test(_test_older_snapshot_resume_latency)
def test_5_inc_snapshots(network_config, bin_cloner_path):
"""Test scenario: 5 incremental snapshots with disk intensive workload."""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.9/4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_4096mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="vmlinux-4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.DIFF,
'seq_len': 5
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_seq_snapshots)
def test_pause_resume(network_config, bin_cloner_path):
"""Test scenario: boot/pause/resume for all available configurations."""
logger = logging.getLogger("pause_resume")
# Currently, artifacts share the bucket with all other resources.
artifact_collection = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifact_collection.microvms())
kernel_artifacts = ArtifactSet(artifact_collection.kernels())
# Restrict root fs to ubuntu.
disk_artifacts = ArtifactSet(artifact_collection.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_pause_resume)
def test_network_latency(bin_cloner_path, results_file_dumper):
"""
Test network latency for multiple vm configurations.
@type: performance
"""
logger = logging.getLogger("network_latency")
microvm_artifacts = ArtifactSet(
ARTIFACTS_COLLECTION.microvms(keyword="1vcpu_1024mb")
)
kernel_artifacts = ArtifactSet(ARTIFACTS_COLLECTION.kernels())
disk_artifacts = ArtifactSet(ARTIFACTS_COLLECTION.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"logger": logger,
"requests": 1000,
"interval": 0.2, # Seconds.
"name": "network_latency",
"results_file_dumper": results_file_dumper,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_g2h_send_ping)
def test_block_performance_sync(bin_cloner_path, results_file_dumper):
"""
Test block performance for multiple vm configurations.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
vm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
vm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': TEST_ID,
'results_file_dumper': results_file_dumper,
'io_engine': 'Sync'
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[vm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(fio_workload)
def test_snapshot_resume_latency(network_config, bin_cloner_path):
"""Test scenario: Snapshot load performance measurement."""
logger = logging.getLogger("snapshot_load")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256/512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.FULL,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_snapshot_resume_latency)
def test_network_latency(network_config, bin_cloner_path):
"""Test network latency driver for multiple artifacts."""
logger = logging.getLogger("network_latency")
microvm_artifacts = ArtifactSet(
ARTIFACTS_COLLECTION.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(ARTIFACTS_COLLECTION.kernels())
disk_artifacts = ArtifactSet(ARTIFACTS_COLLECTION.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'requests': 10,
'interval': 0.2, # Seconds.
'name': 'network_latency'
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_g2h_send_ping)
def test_cmp_full_and_first_diff_mem(network_config, bin_cloner_path):
"""Test scenario: cmp memory of 2 consecutive full and diff snapshots."""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.9/4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="vmlinux-4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_compare_mem_files)
def test_vsock_throughput(bin_cloner_path):
"""Test vsock throughput driver for multiple artifacts."""
logger = logging.getLogger("vsock_throughput")
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(
artifacts.kernels(keyword="vmlinux-4.14.bin"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': 'vsock_throughput'
}
print(get_cpu_model_name())
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(iperf_workload)
def test_cmp_full_and_first_diff_mem(network_config, bin_cloner_path):
"""
Compare memory of 2 consecutive full and diff snapshots.
@type: functional
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"network_config": network_config,
"logger": logger,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_test_compare_mem_files)
def test_snap_restore_performance(bin_cloner_path, results_file_dumper):
"""
Test the performance of snapshot restore.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': TEST_ID,
'results_file_dumper': results_file_dumper
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(snapshot_workload)
def build_test_matrix(network_config, bin_cloner_path, logger):
"""Build a test matrix using the kernel with the balloon driver."""
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="vmlinux-4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.FULL,
'seq_len': 5
}
# Create the test matrix.
return TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
def test_network_tcp_throughput(bin_cloner_path, results_file_dumper):
"""
Test network throughput for multiple vm confgurations.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"logger": logger,
"name": TEST_ID,
"results_file_dumper": results_file_dumper,
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(iperf_workload)
def test_block_performance(bin_cloner_path):
"""Test network throughput driver for multiple artifacts."""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="1vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': TEST_ID
}
print(f"CPU model: {get_cpu_model_name()}.")
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(fio_workload)
def test_network_tcp_throughput(bin_cloner_path, results_file_dumper):
"""Test network throughput driver for multiple artifacts."""
logger = logging.getLogger("network_tcp_throughput")
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="1vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': 'network_tcp_throughput',
'results_file_dumper': results_file_dumper
}
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(iperf_workload)
def main():
"""
Run the main logic.
Create snapshot artifacts from complex microVMs with all Firecracker's
functionality enabled. The kernels are parametrized to include all guest
supported versions.
Artifacts are saved in the following format:
snapshot_artifacts
|
-> <guest_kernel_supported_0>_<cpu_template>_guest_snapshot
|
-> vm.mem
-> vm.vmstate
-> ubuntu-18.04.id_rsa
-> ubuntu-18.04.ext4
-> <guest_kernel_supported_1>_<cpu_template>_guest_snapshot
|
...
"""
# Create directory dedicated to store snapshot artifacts for
# each guest kernel version.
shutil.rmtree(SNAPSHOT_ARTIFACTS_ROOT_DIR, ignore_errors=True)
os.mkdir(SNAPSHOT_ARTIFACTS_ROOT_DIR)
root_path = tempfile.mkdtemp(prefix=MicrovmBuilder.ROOT_PREFIX,
dir=f"{DEFAULT_TEST_SESSION_ROOT_PATH}")
# Compile new-pid cloner helper.
bin_cloner_path = compile_file(file_name='newpid_cloner.c',
bin_name='newpid_cloner',
dest_path=root_path)
# Fetch kernel and rootfs artifacts from S3 bucket.
artifacts = ArtifactCollection(_test_images_s3_bucket())
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
cpu_templates = ["None"]
if get_cpu_vendor() == CpuVendor.INTEL:
cpu_templates.extend(["C3", "T2"])
for cpu_template in cpu_templates:
# Create a test context.
test_context = TestContext()
test_context.custom = {
'bin_cloner_path': bin_cloner_path,
'session_root_path': root_path,
'cpu_template': cpu_template
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[kernel_artifacts, disk_artifacts])
test_matrix.run_test(create_snapshots)
def test_snapshot_create_diff_latency(network_config,
bin_cloner_path,
results_file_dumper):
"""
Test scenario: Diff snapshot create performance measurement.
@type: performance
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256/512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.DIFF,
'name': 'create_diff_latency',
'results_file_dumper': results_file_dumper
}
# Create the test matrix.
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(_test_snapshot_create_latency)
def test_5_inc_snapshots(network_config, bin_cloner_path, bin_vsock_path,
test_fc_session_root_path):
"""
Create and load 5 incremental snapshots.
@type: functional
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 4096 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_4096mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"network_config": network_config,
"logger": logger,
"snapshot_type": SnapshotType.DIFF,
"seq_len": 5,
"bin_vsock_path": bin_vsock_path,
"test_fc_session_root_path": test_fc_session_root_path,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_test_seq_snapshots)
def test_5_full_snapshots(network_config, bin_cloner_path, bin_vsock_path,
test_fc_session_root_path):
"""
Create and load 5 full sequential snapshots.
@type: functional
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.FULL,
'seq_len': 5,
'bin_vsock_path': bin_vsock_path,
'test_fc_session_root_path': test_fc_session_root_path
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_seq_snapshots)
def test_snapshot_create_full_latency(network_config, bin_cloner_path,
results_file_dumper):
"""
Test scenario: Full snapshot create performance measurement.
@type: performance
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256/512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"network_config": network_config,
"logger": logger,
"snapshot_type": SnapshotType.FULL,
"name": "create_full_latency",
"results_file_dumper": results_file_dumper,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_test_snapshot_create_latency)
def test_block_performance_async(bin_cloner_path, results_file_dumper):
"""
Test block performance for multiple vm configurations.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
if not is_io_uring_supported():
logger.info("io_uring is not supported. Skipping..")
pytest.skip("Cannot run async if io_uring is not supported")
artifacts = ArtifactCollection(_test_images_s3_bucket())
vm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
vm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"logger": logger,
"name": TEST_ID,
"results_file_dumper": results_file_dumper,
"io_engine": "Async",
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[vm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(fio_workload)