Added scheme to globally number threads, packages, and NUMA nodes

Author: hunhoffe

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

@@ -62,12 +62,12 @@ pub(crate) fn get_frame_as(frame_id: u64) -> Result<u64, RPCError> {
     }
 }
 
-pub(crate) fn get_num_clients() -> u64 {
-    (crate::CMDLINE.get().map_or(2, |c| c.workers) - 1) as u64
+pub(crate) fn get_num_clients() -> ClientId {
+    (crate::CMDLINE.get().map_or(2, |c| c.workers) - 1) as ClientId
 }
 
-pub(crate) fn get_local_client_id() -> u64 {
-    (crate::CMDLINE.get().map_or(1, |c| c.machine_id) - 1) as u64
+pub(crate) fn get_local_client_id() -> ClientId {
+    (crate::CMDLINE.get().map_or(1, |c| c.machine_id) - 1) as ClientId
 }
 
 pub(crate) fn client_get_work() -> () {

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

@@ -66,7 +66,7 @@ lazy_static! {
 }
 
 lazy_static! {
-    pub(crate) static ref HWTHREADS: Arc<Mutex<Vec<(ClientId, CpuThread)>>> = {
+    pub(crate) static ref HWTHREADS: Arc<Mutex<Vec<CpuThread>>> = {
         let mut hwthreads = Vec::try_with_capacity(get_num_clients() as usize)
             .expect("Failed to create vector for rack cpu threads");
         Arc::new(Mutex::new(hwthreads))

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

@@ -15,6 +15,7 @@ use rpc::RPCClient;
 
 use super::dcm::node_registration::dcm_register_node;
 use crate::arch::rackscale::controller::{HWTHREADS, SHMEM_MANAGERS};
+use crate::arch::rackscale::systemops::{local_to_gtid, local_to_node_id, local_to_package_id};
 use crate::error::KResult;
 use crate::memory::LARGE_PAGE_SIZE;
 use crate::transport::shmem::{create_shmem_manager, get_affinity_shmem};
@@ -125,31 +126,39 @@ pub(crate) fn register_client(
             if remaining.len() == 0 {
                 // Register client resources with DCM, DCM doesn't care about pids, so
                 // send w/ dummy pid
-                let node_id = dcm_register_node(0, req.num_cores, memslices);
-                info!("Registered client DCM, assigned client_id={:?}", node_id);
+                let client_id = dcm_register_node(0, req.num_cores, memslices);
+                info!("Registered client DCM, assigned client_id={:?}", client_id);
 
                 // Create shmem memory manager
-                // Probably not most accurate to use node_id for affinity here
+                // Probably not most accurate to use client_id for affinity here
                 let mut managers = SHMEM_MANAGERS.lock();
-                managers[node_id as usize] = create_shmem_manager(
+                managers[client_id as usize] = create_shmem_manager(
                     req.affinity_shmem_offset,
                     req.affinity_shmem_size,
-                    node_id,
+                    client_id,
                 );
                 log::info!(
                     "Created shmem manager on behalf of client {:?}: {:?}",
-                    node_id,
-                    managers[node_id as usize]
+                    client_id,
+                    managers[client_id as usize]
                 );
 
                 // Record information about the hardware threads
                 info!("hwthreads: {:?}", hwthreads);
                 let mut rack_threads = HWTHREADS.lock();
                 for hwthread in hwthreads {
-                    rack_threads.push((node_id, *hwthread));
+                    rack_threads.push(CpuThread {
+                        // these are global values to make sure no conflicts across rack
+                        id: local_to_gtid(hwthread.id, client_id),
+                        node_id: local_to_node_id(hwthread.node_id, client_id),
+                        package_id: local_to_package_id(hwthread.package_id, client_id),
+                        // these are local relative to below, so no work to do
+                        core_id: hwthread.core_id,
+                        thread_id: hwthread.thread_id,
+                    });
                 }
 
-                Ok(node_id)
+                Ok(client_id)
             } else {
                 error!("Extra data in register_client");
                 Err(RPCError::MalformedResponse)

kernel/src/arch/x86_64/rackscale/systemops/get_hardware_threads.rs

@@ -82,29 +82,20 @@ pub(crate) fn handle_get_hardware_threads(
     }
     let local_pid = local_pid.unwrap();
 
-    let rack_threads = HWTHREADS.lock();
-
-    // calculate total number of threads
-    let mut hwthreads =
-        Vec::try_with_capacity(rack_threads.len()).expect("failed to allocate space for hwthreads");
-    for i in 0..rack_threads.len() {
-        hwthreads.push(rack_threads[i].1);
-    }
-    log::info!(
-        "Found {:?} hardware threads: {:?}",
-        hwthreads.len(),
-        hwthreads
-    );
-
     // Encode hwthread information into payload buffer
+    let rack_threads = HWTHREADS.lock();
     let start = KernelRpcRes_SIZE as usize;
     let end = start
-        + hwthreads.len() * core::mem::size_of::<CpuThread>()
+        + rack_threads.len() * core::mem::size_of::<CpuThread>()
         + core::mem::size_of::<Vec<CpuThread>>();
     let additional_data = end - start;
-    unsafe { encode(&hwthreads, &mut &mut payload[start..end]) }
+    unsafe { encode(&*rack_threads, &mut &mut payload[start..end]) }
         .expect("Failed to encode hardware thread vector");
-    log::info!("Sending back {:?} bytes of data", additional_data);
+    log::info!(
+        "Sending back {:?} bytes of data ({:?} hwthreads)",
+        additional_data,
+        rack_threads.len()
+    );
 
     // Construct return
     let res = KernelRpcRes {

kernel/src/arch/x86_64/rackscale/systemops/mod.rs

@@ -1,4 +1,48 @@
 // Copyright © 2022 University of Colorado. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
+use kpi::system::{GlobalThreadId, NodeId, PackageId};
+use rpc::rpc::ClientId;
+
+use crate::arch::rackscale::client::get_num_clients;
+
 pub mod get_hardware_threads;
+
+// Helper functions for CpuThread GlobalThreadId
+pub(crate) fn local_to_gtid(gtid: GlobalThreadId, client_id: ClientId) -> GlobalThreadId {
+    get_num_clients() as GlobalThreadId * gtid + client_id as GlobalThreadId
+}
+
+pub(crate) fn gtid_to_local(gtid: GlobalThreadId, client_id: ClientId) -> GlobalThreadId {
+    (gtid - client_id as GlobalThreadId) / get_num_clients() as GlobalThreadId
+}
+
+pub(crate) fn is_gtid_local(gtid: GlobalThreadId, client_id: ClientId) -> bool {
+    gtid % get_num_clients() as GlobalThreadId == client_id as GlobalThreadId
+}
+
+// Helper functions for CpuThread NodeId
+pub(crate) fn local_to_node_id(node_id: NodeId, client_id: ClientId) -> NodeId {
+    get_num_clients() as NodeId * node_id + client_id as NodeId
+}
+
+pub(crate) fn node_id_to_local(node_id: NodeId, client_id: ClientId) -> NodeId {
+    (node_id - client_id as NodeId) / get_num_clients() as NodeId
+}
+
+pub(crate) fn is_node_id_local(node_id: NodeId, client_id: ClientId) -> bool {
+    node_id % get_num_clients() as NodeId == client_id as NodeId
+}
+
+// Helper functions for CpuThread PackageId
+pub(crate) fn local_to_package_id(package_id: PackageId, client_id: ClientId) -> PackageId {
+    get_num_clients() as PackageId * package_id + client_id as PackageId
+}
+
+pub(crate) fn package_id_to_local(package_id: PackageId, client_id: ClientId) -> PackageId {
+    (package_id - client_id as PackageId) / get_num_clients() as PackageId
+}
+
+pub(crate) fn is_package_id_local(package_id: PackageId, client_id: ClientId) -> bool {
+    package_id % get_num_clients() as PackageId == client_id as PackageId
+}