def _check_cache_topology(test_microvm, num_vcpus_on_lvl_1_cache,
num_vcpus_on_lvl_3_cache):
expected_lvl_1_str = '{} ({})'.format(hex(num_vcpus_on_lvl_1_cache),
num_vcpus_on_lvl_1_cache)
expected_lvl_3_str = '{} ({})'.format(hex(num_vcpus_on_lvl_3_cache),
num_vcpus_on_lvl_3_cache)
cpu_vendor = get_cpu_vendor()
if cpu_vendor == CpuVendor.AMD:
expected_level_1_topology = {
"level": '0x1 (1)',
"extra cores sharing this cache": expected_lvl_1_str
}
expected_level_3_topology = {
"level": '0x3 (3)',
"extra cores sharing this cache": expected_lvl_3_str
}
elif cpu_vendor == CpuVendor.INTEL:
expected_level_1_topology = {
"cache level": '0x1 (1)',
"extra threads sharing this cache": expected_lvl_1_str,
}
expected_level_3_topology = {
"cache level": '0x3 (3)',
"extra threads sharing this cache": expected_lvl_3_str,
}
_check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 0 ---", '=',
expected_level_1_topology)
_check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 1 ---", '=',
expected_level_1_topology)
_check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 2 ---", '=',
expected_level_1_topology)
_check_guest_cmd_output(test_microvm, "cpuid -1", "--- cache 3 ---", '=',
expected_level_3_topology)
def test_cpu_template(test_microvm_with_ssh, network_config, cpu_template):
"""Check that AVX2 & AVX512 instructions are disabled.
This is a rather dummy test for checking that some features are not
exposed by mistake. It is a first step into checking the t2 & c3
templates. In a next iteration we should check **all** cpuid entries, not
just these features. We can achieve this with a template
containing all features on a t2/c3 instance and check that the cpuid in
the guest is an exact match of the template.
"""
common_masked_features = ["avx512", "mpx", "clflushopt", "clwb", "xsavec",
"xgetbv1", "xsaves", "pku", "ospke"]
c3_masked_features = ["avx2"]
test_microvm = test_microvm_with_ssh
test_microvm.spawn()
test_microvm.basic_config(vcpu_count=1)
# Set template as specified in the `cpu_template` parameter.
response = test_microvm.machine_cfg.put(
vcpu_count=1,
mem_size_mib=256,
ht_enabled=False,
cpu_template=cpu_template,
)
assert test_microvm.api_session.is_status_no_content(response.status_code)
_tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
response = test_microvm.actions.put(action_type='InstanceStart')
if get_cpu_vendor() != CpuVendor.INTEL:
# We shouldn't be able to apply Intel templates on AMD hosts
assert test_microvm.api_session.is_status_bad_request(
response.status_code)
return
assert test_microvm.api_session.is_status_no_content(
response.status_code)
ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
guest_cmd = "cat /proc/cpuinfo | grep 'flags' | head -1"
_, stdout, stderr = ssh_connection.execute_command(guest_cmd)
assert stderr.read() == ''
cpu_flags_output = stdout.readline().rstrip()
if cpu_template == "C3":
for feature in c3_masked_features:
assert feature not in cpu_flags_output
# Check that all features in `common_masked_features` are properly masked.
for feature in common_masked_features:
assert feature not in cpu_flags_output
# Check if XSAVE PKRU is masked for T3/C2.
expected_cpu_features = {
"XCR0 supported: PKRU state": "false"
}
_check_guest_cmd_output(test_microvm, "cpuid -1", None, '=',
expected_cpu_features)
def test_brand_string(test_microvm_with_ssh, network_config):
"""Ensure good formatting for the guest band string.
* For Intel CPUs, the guest brand string should be:
Intel(R) Xeon(R) Processor @ {host frequency}
where {host frequency} is the frequency reported by the host CPUID
(e.g. 4.01GHz)
* For AMD CPUs, the guest brand string should be:
AMD EPYC
* For other CPUs, the guest brand string should be:
""
"""
cif = open('/proc/cpuinfo', 'r')
host_brand_string = None
while True:
line = cif.readline()
if line == '':
break
mo = re.search("^model name\\s+:\\s+(.+)$", line)
if mo:
host_brand_string = mo.group(1)
cif.close()
assert host_brand_string is not None
test_microvm = test_microvm_with_ssh
test_microvm.spawn()
test_microvm.basic_config(vcpu_count=1)
_tap, _, _ = test_microvm.ssh_network_config(network_config, '1')
test_microvm.start()
ssh_connection = net_tools.SSHConnection(test_microvm.ssh_config)
guest_cmd = "cat /proc/cpuinfo | grep 'model name' | head -1"
_, stdout, stderr = ssh_connection.execute_command(guest_cmd)
assert stderr.read() == ''
line = stdout.readline().rstrip()
mo = re.search("^model name\\s+:\\s+(.+)$", line)
assert mo
guest_brand_string = mo.group(1)
assert guest_brand_string
cpu_vendor = get_cpu_vendor()
expected_guest_brand_string = ""
if cpu_vendor == CpuVendor.AMD:
expected_guest_brand_string += "AMD EPYC"
elif cpu_vendor == CpuVendor.INTEL:
expected_guest_brand_string = "Intel(R) Xeon(R) Processor"
mo = re.search("[.0-9]+[MG]Hz", host_brand_string)
if mo:
expected_guest_brand_string += " @ " + mo.group(0)
assert guest_brand_string == expected_guest_brand_string
'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_create_latency)
@pytest.mark.skipif(platform.machine() != "x86_64"
or get_cpu_vendor() == CpuVendor.AMD,
reason="Not supported yet.")
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"))