Measure remote call overhead

Author: fwsGonzo

guest/rust_storage/src/main.rs

@@ -5,6 +5,9 @@ use std::process::ExitCode;
 extern "C" fn do_calculation(input: i32) -> i32 {
     return unsafe { remote_function(double_int, input) };
 }
+extern "C" fn do_nothing(_input: i32) -> i32 {
+	return 42;
+}
 
 extern "C" fn double_int(input: i32) -> i32 {
     return input * 2;
@@ -14,13 +17,15 @@ extern "C" fn double_int(input: i32) -> i32 {
 // in a dynamic ELF w/interpreter. We don't know the
 // base address of the binary, so we can't adjust the
 // symbol address.
-fn set_callback(_cb: extern "C" fn(i32) -> i32) {
+fn set_callback(name: &str, cb: extern "C" fn(i32) -> i32) {
 	let sysnum = 0x10001; // Set callback syscall
 	unsafe {
 		asm!(
 			"out 0, eax",
 			in("eax") sysnum,
-			in("rdi") _cb
+			in("rdi") cb,
+			in("rsi") name.as_ptr(),
+			in("rdx") name.len()
 		);
 	}
 }
@@ -30,6 +35,7 @@ fn main() -> ExitCode
 	println!("Hello, world!");
 	let result = unsafe { remote_function(double_int, 21) };
 	println!("Result from remote function: {}", result);
-	set_callback(do_calculation);
+	set_callback("do_calculation", do_calculation);
+	set_callback("do_nothing", do_nothing);
 	return ExitCode::from(result as u8);
 }

lib/tinykvm/machine.hpp

@@ -95,6 +95,7 @@ struct Machine
 		const char* end() const noexcept { return sv.end(); }
 		const char* c_str() const noexcept { return sv.begin(); }
 		size_t size() const noexcept { return sv.size(); }
+		std::string to_string() const { return std::string{sv}; }
 
 		bool is_sequential() const noexcept { return str.empty(); }
 

src/storage.cpp

@@ -126,14 +126,18 @@ int main(int argc, char** argv)
 
 	master_vm.remote_connect(storage_vm, false);
 
-	static uint64_t callback_address = 0x0;
+	static std::map<std::string, uint64_t> callback_address;
 	master_vm.install_unhandled_syscall_handler(
 	[] (tinykvm::vCPU& cpu, unsigned sysnum) {
 		auto& regs = cpu.registers();
 		switch (sysnum) {
-			case 0x10001: // Set callback address
-				callback_address = regs.rdi;
-				return;
+			case 0x10001: { // Set callback address
+					auto view = cpu.machine().string_or_view(regs.rsi, regs.rdx);
+					const std::string name = view.to_string();
+					callback_address[name] = regs.rdi;
+					printf("Set callback '%s' to 0x%llX\n", name.c_str(), regs.rdi);
+					return;
+				}
 			default:
 				printf("Unhandled master VM syscall: %u\n", sysnum);
 				regs.rax = -ENOSYS;
@@ -167,15 +171,29 @@ int main(int argc, char** argv)
 	assert(vm.is_remote_connected());
 
 	/* Call 'do_calculation' with 21 as argument */
-	if (callback_address == 0) {
+	auto do_it = callback_address.find("do_nothing");
+	if (do_it == callback_address.end()) {
+		fprintf(stderr, "Error: no do_nothing() in guest\n");
+		exit(1);
+	}
+	auto calc_it = callback_address.find("do_calculation");
+	if (calc_it == callback_address.end()) {
 		fprintf(stderr, "Error: no do_calculation() in guest\n");
 		exit(1);
 	}
-	printf("Calling do_calculation() @ 0x%lX\n", callback_address);
-	for (int i = 0; i < 100; i++)
-		vm.timed_vmcall(callback_address, 5.0f, 21);
+	auto call_overhead = timed_action([&] {
+		for (int i = 0; i < 100; i++)
+			vm.timed_vmcall(do_it->second, 5.0f, 21);
+	}) / 100.0;
+	printf("Call overhead: %.2fus\n", call_overhead * 1e6);
+
+	printf("Calling do_calculation() @ 0x%lX\n", calc_it->second);
+	for (int i = 0; i < 10; i++)
+		vm.timed_vmcall(calc_it->second, 5.0f, 21);
 	auto fork_tdiff = timed_action([&] {
-		vm.timed_vmcall(callback_address, 5.0f, 21);
-	});
-	printf("Fork call time: %.2fus Return value: %ld\n", fork_tdiff*1e6, vm.return_value());
+		for (int i = 0; i < 100; i++)
+			vm.timed_vmcall(calc_it->second, 5.0f, 21);
+	}) / 100.0;
+	fork_tdiff -= call_overhead;
+	printf("Remote call time: %.2fus Return value: %ld\n", fork_tdiff * 1e6, vm.return_value());
 }