def _g2h_send_ping(context):
"""Send ping from guest to host."""
logger = context.custom['logger']
vm_builder = context.custom['builder']
interval_between_req = context.custom['interval']
name = context.custom['name']
file_dumper = context.custom['results_file_dumper']
logger.info("Testing {} with microvm: \"{}\", kernel {}, disk {} ".format(
name, context.microvm.name(), context.kernel.name(),
context.disk.name()))
# Create a rw copy artifact.
rw_disk = context.disk.copy()
# Get ssh key from read-only artifact.
ssh_key = context.disk.ssh_key()
# Create a fresh microvm from aftifacts.
basevm = vm_builder.build(kernel=context.kernel,
disks=[rw_disk],
ssh_key=ssh_key,
config=context.microvm)
basevm.start()
# Check if the needed CPU cores are available. We have the API thread, VMM
# thread and then one thread for each configured vCPU.
assert CpuMap.len() >= 2 + basevm.vcpus_count
# Pin uVM threads to physical cores.
current_cpu_id = 0
assert basevm.pin_vmm(current_cpu_id), \
"Failed to pin firecracker thread."
current_cpu_id += 1
assert basevm.pin_api(current_cpu_id), \
"Failed to pin fc_api thread."
for i in range(basevm.vcpus_count):
current_cpu_id += 1
assert basevm.pin_vcpu(i, current_cpu_id + i), \
f"Failed to pin fc_vcpu {i} thread."
custom = {
"microvm": context.microvm.name(),
"kernel": context.kernel.name(),
"disk": context.disk.name(),
"cpu_model_name": get_cpu_model_name()
}
st_core = core.Core(name="network_latency", iterations=1, custom=custom)
cons = consumer.LambdaConsumer(
func=consume_ping_output,
func_kwargs={"requests": context.custom['requests']})
cmd = PING.format(context.custom['requests'], interval_between_req,
DEFAULT_HOST_IP)
prod = producer.SSHCommand(cmd, net_tools.SSHConnection(basevm.ssh_config))
st_core.add_pipe(producer=prod, consumer=cons, tag="ping")
# Gather results and verify pass criteria.
result = st_core.run_exercise(file_dumper is None)
if file_dumper:
file_dumper.writeln(json.dumps(result))
def pipes(basevm, current_avail_cpu, env_id):
"""Producer/Consumer pipes generator."""
host_cpu_model_name = get_cpu_model_name()
cpus_baselines = test_cfg.CONFIG["hosts"]["instances"]["m5d.metal"]["cpus"]
stats = no_criteria_stats()
baselines = list(
filter(lambda baseline: baseline["model"] == host_cpu_model_name,
cpus_baselines))
for mode in test_cfg.CONFIG["modes"]:
# We run bi-directional tests only on uVM with more than 2 vCPus
# because we need to pin one iperf3/direction per vCPU, and since we
# have two directions, we need at least two vCPUs.
if mode == "bd" and basevm.vcpus_count < 2:
continue
for protocol in test_cfg.CONFIG["protocols"]:
host_cpu_model_name = get_cpu_model_name()
for payload_length in protocol["payload_length"]:
iperf_guest_cmd_builder = CmdBuilder(test_cfg.IPERF3) \
.with_arg("--vsock") \
.with_arg("-c", 2) \
.with_arg("--json") \
.with_arg("--omit", protocol["omit"]) \
.with_arg("--time", test_cfg.CONFIG["time"])
if payload_length:
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--len", f"{payload_length}")
iperf3_id_payload_len = payload_length
else:
iperf3_id_payload_len = "DEFAULT"
iperf3_id = f"vsock-p{iperf3_id_payload_len}" \
f"-{basevm.vcpus_count}vcpu-{mode}"
cons = consumer.LambdaConsumer(consume_stats=False,
func=consume_iperf_output)
if len(baselines) > 0:
stats = criteria_stats(baselines[0], iperf3_id, env_id)
eager_map(cons.set_measurement_def, measurements())
eager_map(cons.set_stat_def, stats)
prod_kwargs = {
"guest_cmd_builder": iperf_guest_cmd_builder,
"basevm": basevm,
"current_avail_cpu": current_avail_cpu,
"runtime": test_cfg.CONFIG["time"],
"omit": protocol["omit"],
"load_factor": test_cfg.CONFIG["load_factor"],
"modes": test_cfg.CONFIG["modes"][mode],
}
prod = producer.LambdaProducer(produce_iperf_output,
prod_kwargs)
yield cons, prod, f"{env_id}/{iperf3_id}"
def create_pipes_generator(basevm,
mode,
current_avail_cpu,
protocol,
host_ip,
env_id):
"""Create producer/consumer pipes."""
host_cpu_model_name = get_cpu_model_name()
for payload_length in protocol["payload_length"]:
for ws in protocol["window_size"]:
iperf_guest_cmd_builder = CmdBuilder(IPERF3) \
.with_arg("--verbose") \
.with_arg("--client", host_ip) \
.with_arg("--time", CONFIG["time"]) \
.with_arg("--json") \
.with_arg("--omit", protocol["omit"])
if ws:
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--window", f"{ws}")
iperf3_id_ws = ws
else:
iperf3_id_ws = "DEFAULT"
if payload_length:
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--len", f"{payload_length}")
iperf3_id_payload_len = payload_length
else:
iperf3_id_payload_len = "DEFAULT"
iperf3_id = f"tcp-p{iperf3_id_payload_len}" \
f"-ws{iperf3_id_ws}-{basevm.vcpus_count}vcpu-{mode}"
cons = consumer.LambdaConsumer(
consume_stats=True,
func=consume_iperf_tcp_output,
func_kwargs={
"vcpus_count": basevm.vcpus_count
}
)
eager_map(cons.set_measurement_def, measurements_tcp())
eager_map(cons.set_stat_def, stats_tcp(host_cpu_model_name,
iperf3_id, env_id))
prod_kwargs = {
"guest_cmd_builder": iperf_guest_cmd_builder,
"basevm": basevm,
"current_avail_cpu": current_avail_cpu,
"runtime": CONFIG["time"],
"omit": protocol["omit"],
"load_factor": CONFIG["load_factor"],
"modes": CONFIG["modes"][mode]
}
prod = producer.LambdaProducer(produce_iperf_output,
prod_kwargs)
yield cons, prod, f"{env_id}/{iperf3_id}"
def create_pipes_generator(basevm,
mode,
current_avail_cpu,
protocol,
host_ip,
env_id):
"""Create producer/consumer pipes."""
for payload_length in protocol["payload_length"]:
for ws in protocol["window_size"]:
iperf_guest_cmd_builder = CmdBuilder(IPERF3) \
.with_arg("--verbose") \
.with_arg("--client", host_ip) \
.with_arg("--time", CONFIG["time"]) \
.with_arg("--json") \
.with_arg("--omit", protocol["omit"])
if ws != "DEFAULT":
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--window", f"{ws}")
if payload_length != "DEFAULT":
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--len", f"{payload_length}")
iperf3_id = f"tcp-p{payload_length}-ws{ws}-" \
f"{basevm.vcpus_count}vcpu-{mode}"
cons = consumer.LambdaConsumer(
metadata_provider=DictMetadataProvider(
measurements=CONFIG["measurements"],
baseline_provider=NetTCPThroughputBaselineProvider(
env_id, iperf3_id)),
func=consume_iperf_tcp_output,
func_kwargs={"vcpus_count": basevm.vcpus_count}
)
prod_kwargs = {
"guest_cmd_builder": iperf_guest_cmd_builder,
"basevm": basevm,
"current_avail_cpu": current_avail_cpu,
"runtime": CONFIG["time"],
"omit": protocol["omit"],
"load_factor": CONFIG["load_factor"],
"modes": CONFIG["modes"][mode]
}
prod = producer.LambdaProducer(produce_iperf_output,
prod_kwargs)
yield cons, prod, f"{env_id}/{iperf3_id}"
def _g2h_send_ping(context):
"""Send ping from guest to host."""
logger = context.custom['logger']
vm_builder = context.custom['builder']
network_config = context.custom['network_config']
interval_between_req = context.custom['interval']
name = context.custom['name']
logger.info("Testing {} with microvm: \"{}\", kernel {}, disk {} ".format(
name, context.microvm.name(), context.kernel.name(),
context.disk.name()))
# Create a rw copy artifact.
rw_disk = context.disk.copy()
# Get ssh key from read-only artifact.
ssh_key = context.disk.ssh_key()
# Create a fresh microvm from aftifacts.
basevm = vm_builder.build(kernel=context.kernel,
disks=[rw_disk],
ssh_key=ssh_key,
config=context.microvm,
network_config=network_config)
_tap, host_ip, _ = basevm.ssh_network_config(network_config, '1')
basevm.start()
custom = {
"microvm": context.microvm.name(),
"kernel": context.kernel.name(),
"disk": context.disk.name()
}
st_core = core.Core(name="network_latency", iterations=1, custom=custom)
cons = consumer.LambdaConsumer(
consume_stats=True,
func=consume_ping_output,
func_kwargs={"requests": context.custom['requests']})
prod = producer.SSHCommand(
PING.format(context.custom['requests'], interval_between_req, host_ip),
net_tools.SSHConnection(basevm.ssh_config))
st_core.add_pipe(producer=prod, consumer=cons, tag="ping")
# Gather results and verify pass criteria.
st_core.run_exercise()
def pipes(basevm, current_avail_cpu, env_id):
"""Producer/Consumer pipes generator."""
for mode in CONFIG["modes"]:
# We run bi-directional tests only on uVM with more than 2 vCPus
# because we need to pin one iperf3/direction per vCPU, and since we
# have two directions, we need at least two vCPUs.
if mode == "bd" and basevm.vcpus_count < 2:
continue
for protocol in CONFIG["protocols"]:
for payload_length in protocol["payload_length"]:
iperf_guest_cmd_builder = CmdBuilder(IPERF3) \
.with_arg("--vsock") \
.with_arg("-c", 2) \
.with_arg("--json") \
.with_arg("--omit", protocol["omit"]) \
.with_arg("--time", CONFIG["time"])
if payload_length != "DEFAULT":
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--len", f"{payload_length}")
iperf3_id = f"vsock-p{payload_length}" \
f"-{basevm.vcpus_count}vcpu-{mode}"
cons = consumer.LambdaConsumer(
metadata_provider=DictMetadataProvider(
CONFIG["measurements"],
VsockThroughputBaselineProvider(env_id, iperf3_id)),
func=consume_iperf_output)
prod_kwargs = {
"guest_cmd_builder": iperf_guest_cmd_builder,
"basevm": basevm,
"current_avail_cpu": current_avail_cpu,
"runtime": CONFIG["time"],
"omit": protocol["omit"],
"load_factor": CONFIG["load_factor"],
"modes": CONFIG["modes"][mode],
}
prod = producer.LambdaProducer(produce_iperf_output,
prod_kwargs)
yield cons, prod, f"{env_id}/{iperf3_id}"
def create_pipes_generator(basevm,
mode,
current_avail_cpu,
protocol,
host_ip,
env_id):
"""Create producer/consumer pipes."""
host_cpu_model_name = get_cpu_model_name()
cpus_baselines = test_cfg.CONFIG["hosts"]["instances"]["m5d.metal"]["cpus"]
stats = no_criteria_stats()
baselines = list(filter(
lambda baseline: baseline["model"] == host_cpu_model_name,
cpus_baselines))
for payload_length in protocol["payload_length"]:
for ws in protocol["window_size"]:
iperf_guest_cmd_builder = CmdBuilder(test_cfg.IPERF3) \
.with_arg("--verbose") \
.with_arg("--client", host_ip) \
.with_arg("--time", test_cfg.CONFIG["time"]) \
.with_arg("--json") \
.with_arg("--omit", protocol["omit"])
if ws:
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--window", f"{ws}")
iperf3_id_ws = ws
else:
iperf3_id_ws = "DEFAULT"
if payload_length:
iperf_guest_cmd_builder = iperf_guest_cmd_builder \
.with_arg("--len", f"{payload_length}")
iperf3_id_payload_len = payload_length
else:
iperf3_id_payload_len = "DEFAULT"
iperf3_id = f"tcp-p{iperf3_id_payload_len}" \
f"-ws{iperf3_id_ws}-{basevm.vcpus_count}vcpu-{mode}"
cons = consumer.LambdaConsumer(
consume_stats=False,
func=consume_iperf_tcp_output,
func_kwargs={
"vcpus_count": basevm.vcpus_count
}
)
if len(baselines) > 0:
stats = criteria_stats(baselines[0], iperf3_id, env_id)
eager_map(cons.set_measurement_def, measurements())
eager_map(cons.set_stat_def, stats)
prod_kwargs = {
"guest_cmd_builder": iperf_guest_cmd_builder,
"basevm": basevm,
"current_avail_cpu": current_avail_cpu,
"runtime": test_cfg.CONFIG["time"],
"omit": protocol["omit"],
"load_factor": test_cfg.CONFIG["load_factor"],
"modes": test_cfg.CONFIG["modes"][mode]
}
prod = producer.LambdaProducer(produce_iperf_output,
prod_kwargs)
yield cons, prod, f"{env_id}/{iperf3_id}"
