Dev/rackscale benchmark framework

doc/src/environment/Environment.md

@@ -13,27 +13,29 @@ in the package repository.
 First, make sure to uncomment all #deb-src lines in /etc/apt/sources.list if not
 already uncommented. Then, run the following commands:
 
+For any build:
 ```bash
 sudo apt update
 sudo apt install build-essential libpmem-dev libdaxctl-dev ninja-build flex bison
 apt source qemu
 sudo apt build-dep qemu
-
-For non-rackscale mode, execute the following:
 ```
+
+For non-rackscale:
+```bash
 wget https://download.qemu.org/qemu-6.0.0.tar.xz
 tar xvJf qemu-6.0.0.tar.xz
 cd qemu-6.0.0
 ```
 
-For rackscale mode, instead run:
-```
-git clone https://github.com/hunhoffe/qemu.git qemu-6.0.0.tar.xz
+For non-rackscale OR rackscale:
+```bash
+git clone https://github.com/hunhoffe/qemu.git qemu-6.0.0
 cd qemu-6.0.0
 git checkout --track origin/dev/ivshmem-numa
 ```
 
-For either option, build and install with:
+For any build:
 ```bash
 ./configure --enable-rdma --enable-libpmem
 make -j 28
@@ -48,7 +50,7 @@ You can also add `--enable-debug` to the configure script which will add debug
 information (useful for source information when stepping through qemu code in
 gdb).
 
-Note that if you are only updating the ```ivshmem-server```, it may not install
-correctly with the ```make install``` command above. Instead, you can use
-```which ivshmem-server``` to find the current location and then overwrite it
-with ```qemu-6.0.0/build/contrib/ivshmem-server/ivshmem-server```. 
+Note that sometimes ```make install``` doesn't actually replace the 
+```ivshmem-server```. Use ```which ivshmem-server``` to find the current 
+location and then overwrite it with 
+```qemu/build/contrib/ivshmem-server/ivshmem-server```. 

kernel/build.rs

@@ -34,7 +34,7 @@ fn main() {
     }
 
     let output = Command::new("git")
-        .args(&["rev-parse", "HEAD"])
+        .args(["rev-parse", "HEAD"])
         .output()
         .expect("Could not determine git hash");
     let git_hash = String::from_utf8(output.stdout).expect("Could not parse the git hash");

kernel/src/arch/x86_64/rackscale/client_state.rs

@@ -16,6 +16,7 @@ use rpc::client::Client;
 use rpc::rpc::RPCError;
 
 use crate::arch::kcb::try_per_core_mem;
+use crate::arch::rackscale::controller::CONTROLLER_PORT_BASE;
 use crate::arch::rackscale::fileops::rw::{RW_SHMEM_BUF, RW_SHMEM_BUF_LEN};
 use crate::arch::rackscale::FrameCacheBase;
 use crate::arch::MAX_MACHINES;
@@ -47,7 +48,7 @@ impl ClientState {
             Arc::new(Mutex::new(
                 crate::transport::ethernet::init_ethernet_rpc(
                     smoltcp::wire::IpAddress::v4(172, 31, 0, 11),
-                    6970,
+                    CONTROLLER_PORT_BASE + (*crate::environment::MACHINE_ID as u16 - 1),
                     true,
                 )
                 .expect("Failed to initialize ethernet RPC"),

kernel/src/arch/x86_64/rackscale/controller.rs

@@ -19,7 +19,7 @@ use crate::transport::shmem::create_shmem_transport;
 
 use super::*;
 
-const PORT: u16 = 6970;
+pub(crate) const CONTROLLER_PORT_BASE: u16 = 6970;
 
 /// Controller main method
 pub(crate) fn run() {
@@ -51,19 +51,21 @@ pub(crate) fn run() {
         .get()
         .map_or(false, |c| c.transport == Transport::Ethernet)
     {
-        if num_clients > 1 {
-            panic!("Ethernet transport only supports on client, currently");
-        }
-
-        let transport = Box::try_new(
-            TCPTransport::new(None, PORT, Arc::clone(&ETHERNET_IFACE))
+        for mid in 0..num_clients {
+            let transport = Box::try_new(
+                TCPTransport::new(
+                    None,
+                    CONTROLLER_PORT_BASE + mid as u16,
+                    Arc::clone(&ETHERNET_IFACE),
+                )
                 .expect("Failed to create TCP transport"),
-        )
-        .expect("Out of memory during init");
-        let mut server: Box<dyn RPCServer<ControllerState>> =
-            Box::try_new(Server::new(transport)).expect("Out of memory during init");
-        register_rpcs(&mut server);
-        servers.push(server);
+            )
+            .expect("Out of memory during init");
+            let mut server: Box<dyn RPCServer<ControllerState>> =
+                Box::try_new(Server::new(transport)).expect("Out of memory during init");
+            register_rpcs(&mut server);
+            servers.push(server);
+        }
     } else if crate::CMDLINE
         .get()
         .map_or(false, |c| c.transport == Transport::Shmem)