Remove contention on the gic

dgageot · slp · commit 2254d48b6e12 · 2024-07-10T17:25:00.000+02:00
And move it down to each vcpu

Building the Linux Kernel: 7m21s -&gt; 6:58s
  Building Wasmer: 3m13s -&gt; 2m30s

Signed-off-by: David Gageot &lt;david.gageot@docker.com&gt;
diff --git a/src/devices/src/legacy/gic.rs b/src/devices/src/legacy/gic.rs
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crossbeam_channel::Sender;
-use std::collections::btree_map::Entry;
-use std::collections::{BTreeMap, VecDeque};
+use std::collections::VecDeque;
 use std::convert::TryInto;
+use std::sync::{Arc, Mutex};
 
 use arch::aarch64::gicv2::GICv2;
 use arch::aarch64::layout::GTIMER_VIRT;
@@ -23,32 +23,101 @@ enum VcpuStatus {
 struct VcpuInfo {
     status: VcpuStatus,
     pending_irqs: VecDeque<u32>,
-    wfe_sender: Sender<u32>,
+    wfe_sender: Option<Sender<u32>>,
+}
+
+pub struct VcpuList {
+    vcpus: Vec<Mutex<VcpuInfo>>,
+    vtimer_irq: u32,
+}
+
+impl VcpuList {
+    pub fn new() -> Self {
+        let mut vcpus = Vec::with_capacity(MAX_CPUS as usize);
+        for _ in 0..MAX_CPUS {
+            vcpus.push(Mutex::new(VcpuInfo {
+                status: VcpuStatus::Running,
+                pending_irqs: VecDeque::new(),
+                wfe_sender: None,
+            }));
+        }
+
+        Self {
+            vcpus,
+            vtimer_irq: GTIMER_VIRT + 16,
+        }
+    }
+
+    fn set_irq_common(&self, vcpuid: u8, irq_line: u32) {
+        let vcpu = &mut self.vcpus[vcpuid as usize].lock().unwrap();
+        vcpu.pending_irqs.push_back(irq_line);
+
+        match vcpu.status {
+            VcpuStatus::Waiting => {
+                vcpu.wfe_sender
+                    .as_mut()
+                    .unwrap()
+                    .send(vcpuid as u32)
+                    .unwrap();
+                vcpu.status = VcpuStatus::Running;
+            }
+            VcpuStatus::Running => {
+                vcpu_request_exit(vcpuid as u64).unwrap();
+            }
+        }
+    }
+
+    pub fn set_vtimer_irq(&self, vcpuid: u64) {
+        assert!(vcpuid < MAX_CPUS);
+        self.set_irq_common(vcpuid as u8, self.vtimer_irq);
+    }
+
+    pub fn register(&self, vcpuid: u64, wfe_sender: Sender<u32>) {
+        assert!(vcpuid < MAX_CPUS);
+        let vcpu = &mut self.vcpus[vcpuid as usize].lock().unwrap();
+        vcpu.wfe_sender = Some(wfe_sender);
+    }
+
+    pub fn should_wait(&self, vcpuid: u64) -> bool {
+        assert!(vcpuid < MAX_CPUS);
+        let vcpu = &mut self.vcpus[vcpuid as usize].lock().unwrap();
+        if vcpu.pending_irqs.is_empty() {
+            vcpu.status = VcpuStatus::Waiting;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn has_pending_irq(&self, vcpuid: u64) -> bool {
+        assert!(vcpuid < MAX_CPUS);
+        let vcpu = &mut self.vcpus[vcpuid as usize].lock().unwrap();
+        !vcpu.pending_irqs.is_empty()
+    }
+
+    pub fn get_pending_irq(&self, vcpuid: u8) -> u32 {
+        let vcpu = &mut self.vcpus[vcpuid as usize].lock().unwrap();
+        vcpu.pending_irqs.pop_front().unwrap_or(1023)
+    }
 }
 
 pub struct Gic {
     cpu_size: u64,
     ctlr: u32,
     irq_cfg: [u8; IRQ_NUM as usize],
-    vcpus: BTreeMap<u8, VcpuInfo>,
+    vcpu_list: Arc<VcpuList>,
     vcpu_count: u8,
     irq_target: [u8; IRQ_NUM as usize],
     vtimer_irq: u32,
 }
 
-impl Default for Gic {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Gic {
-    pub fn new() -> Self {
+    pub fn new(vcpu_list: Arc<VcpuList>) -> Self {
         Self {
             cpu_size: GICv2::get_cpu_size(),
             ctlr: 0,
             irq_cfg: [0; IRQ_NUM as usize],
-            vcpus: BTreeMap::new(),
+            vcpu_list,
             vcpu_count: 0,
             irq_target: [0; IRQ_NUM as usize],
             vtimer_irq: GTIMER_VIRT + 16,
@@ -66,105 +135,23 @@ impl Gic {
         GICv2::get_dist_size() + GICv2::get_cpu_size()
     }
 
-    fn set_irq_common(&mut self, vcpuid: u8, irq_line: u32) {
-        match self.vcpus.entry(vcpuid) {
-            Entry::Vacant(_) => {
-                panic!("Unknown vCPU id: {}", vcpuid);
-            }
-            Entry::Occupied(mut vcpu_entry) => {
-                let vcpu = vcpu_entry.get_mut();
-
-                vcpu.pending_irqs.push_back(irq_line);
-
-                match vcpu.status {
-                    VcpuStatus::Waiting => {
-                        vcpu.wfe_sender.send(vcpuid as u32).unwrap();
-                        vcpu.status = VcpuStatus::Running;
-                    }
-                    VcpuStatus::Running => {
-                        vcpu_request_exit(vcpuid as u64).unwrap();
-                    }
-                }
-            }
-        }
+    pub fn add_vcpu(&mut self) {
+        self.vcpu_count += 1;
     }
 
-    pub fn set_sgi_irq(&mut self, vcpuid: u8, irq_line: u32) {
+    fn set_sgi_irq(&self, vcpuid: u8, irq_line: u32) {
         assert!(irq_line < 16);
-        self.set_irq_common(vcpuid, irq_line);
+        self.vcpu_list.set_irq_common(vcpuid, irq_line);
     }
 
-    pub fn set_vtimer_irq(&mut self, vcpuid: u64) {
-        assert!(vcpuid < MAX_CPUS);
-        self.set_irq_common(vcpuid as u8, self.vtimer_irq);
-    }
-
-    pub fn set_irq(&mut self, irq_line: u32) {
+    pub fn set_irq(&self, irq_line: u32) {
         for vcpuid in 0..self.vcpu_count {
             if (self.irq_target[irq_line as usize] & (1 << vcpuid)) == 0 {
                 continue;
             }
 
             debug!("signaling irq={} to vcpuid={}", irq_line, vcpuid);
-
-            self.set_irq_common(vcpuid, irq_line);
-        }
-    }
-
-    pub fn register_vcpu(&mut self, vcpuid: u64, wfe_sender: Sender<u32>) {
-        assert!(vcpuid < MAX_CPUS);
-        self.vcpus.insert(
-            vcpuid as u8,
-            VcpuInfo {
-                status: VcpuStatus::Running,
-                wfe_sender,
-                pending_irqs: VecDeque::new(),
-            },
-        );
-        assert!(self.vcpus.len() <= MAX_CPUS as usize);
-        self.vcpu_count = self.vcpus.len() as u8;
-    }
-
-    pub fn vcpu_should_wait(&mut self, vcpuid: u64) -> bool {
-        assert!(vcpuid < MAX_CPUS);
-        match self.vcpus.entry(vcpuid as u8) {
-            Entry::Vacant(_) => {
-                panic!("Unknown vCPU id: {}", vcpuid);
-            }
-            Entry::Occupied(mut vcpu_entry) => {
-                let vcpu = vcpu_entry.get_mut();
-                if vcpu.pending_irqs.is_empty() {
-                    vcpu.status = VcpuStatus::Waiting;
-                    true
-                } else {
-                    false
-                }
-            }
-        }
-    }
-
-    pub fn vcpu_has_pending_irq(&mut self, vcpuid: u64) -> bool {
-        assert!(vcpuid < MAX_CPUS);
-        match self.vcpus.entry(vcpuid as u8) {
-            Entry::Vacant(_) => {
-                panic!("Unknown vCPU id: {}", vcpuid);
-            }
-            Entry::Occupied(mut vcpu_entry) => {
-                let vcpu = vcpu_entry.get_mut();
-                !vcpu.pending_irqs.is_empty()
-            }
-        }
-    }
-
-    fn get_pending_irq(&mut self, vcpuid: u8) -> u32 {
-        match self.vcpus.entry(vcpuid) {
-            Entry::Vacant(_) => {
-                panic!("Unknown vCPU id: {}", vcpuid);
-            }
-            Entry::Occupied(mut vcpu_entry) => {
-                let vcpu = vcpu_entry.get_mut();
-                vcpu.pending_irqs.pop_front().unwrap_or(1023)
-            }
+            self.vcpu_list.set_irq_common(vcpuid, irq_line);
         }
     }
 
@@ -280,7 +267,7 @@ impl Gic {
 
         let mut val = 0;
         if offset == 0xc {
-            val = self.get_pending_irq(vcpuid as u8);
+            val = self.vcpu_list.get_pending_irq(vcpuid as u8);
         }
         for (i, b) in val.to_le_bytes().iter().enumerate() {
             data[i] = *b;
diff --git a/src/devices/src/legacy/mod.rs b/src/devices/src/legacy/mod.rs
@@ -23,7 +23,7 @@ use aarch64::gpio;
 use aarch64::serial;
 
 #[cfg(target_os = "macos")]
-pub use self::gic::Gic;
+pub use self::gic::{Gic, VcpuList};
 #[cfg(target_arch = "aarch64")]
 pub use self::gpio::Gpio;
 pub use self::i8042::Error as I8042DeviceError;
diff --git a/src/vmm/src/builder.rs b/src/vmm/src/builder.rs
@@ -18,8 +18,9 @@ use super::{Error, Vmm};
 #[cfg(target_arch = "x86_64")]
 use crate::device_manager::legacy::PortIODeviceManager;
 use crate::device_manager::mmio::MMIODeviceManager;
-use devices::legacy::Gic;
-use devices::legacy::Serial;
+#[cfg(target_os = "macos")]
+use devices::legacy::VcpuList;
+use devices::legacy::{Gic, Serial};
 #[cfg(feature = "net")]
 use devices::virtio::Net;
 #[cfg(not(feature = "tee"))]
@@ -472,10 +473,13 @@ pub fn build_microvm(
         (arch::IRQ_BASE, arch::IRQ_MAX),
     );
 
+    #[cfg(target_os = "macos")]
+    let vcpu_list = Arc::new(VcpuList::new());
+
     #[cfg(target_os = "linux")]
     let intc = None;
     #[cfg(target_os = "macos")]
-    let intc = Some(Arc::new(Mutex::new(devices::legacy::Gic::new())));
+    let intc = Some(Arc::new(Mutex::new(Gic::new(vcpu_list.clone()))));
 
     #[cfg(all(target_os = "linux", target_arch = "x86_64", not(feature = "tee")))]
     let boot_ip: GuestAddress = GuestAddress(kernel_bundle.entry_addr);
@@ -539,6 +543,7 @@ pub fn build_microvm(
             start_addr,
             &exit_evt,
             intc.clone().unwrap(),
+            vcpu_list.clone(),
         )
         .map_err(StartMicrovmError::Internal)?;
 
@@ -1039,6 +1044,7 @@ fn create_vcpus_aarch64(
     entry_addr: GuestAddress,
     exit_evt: &EventFd,
     intc: Arc<Mutex<Gic>>,
+    vcpu_list: Arc<VcpuList>,
 ) -> super::Result<Vec<Vcpu>> {
     let mut vcpus = Vec::with_capacity(vcpu_config.vcpu_count as usize);
     let mut boot_senders = Vec::with_capacity(vcpu_config.vcpu_count as usize - 1);
@@ -1058,6 +1064,7 @@ fn create_vcpus_aarch64(
             boot_receiver,
             exit_evt.try_clone().map_err(Error::EventFd)?,
             intc.clone(),
+            vcpu_list.clone(),
         )
         .map_err(Error::Vcpu)?;
 
diff --git a/src/vmm/src/macos/vstate.rs b/src/vmm/src/macos/vstate.rs
@@ -20,7 +20,7 @@ use crate::vmm_config::machine_config::CpuFeaturesTemplate;
 use arch;
 use arch::aarch64::gic::GICDevice;
 use crossbeam_channel::{unbounded, Receiver, RecvTimeoutError, Sender};
-use devices::legacy::Gic;
+use devices::legacy::{Gic, VcpuList};
 use hvf::{HvfVcpu, HvfVm, VcpuExit};
 use utils::eventfd::EventFd;
 use vm_memory::{
@@ -220,6 +220,7 @@ pub struct Vcpu {
     response_sender: Sender<VcpuResponse>,
 
     intc: Arc<Mutex<Gic>>,
+    vcpu_list: Arc<VcpuList>,
 }
 
 impl Vcpu {
@@ -293,6 +294,7 @@ impl Vcpu {
         boot_receiver: Option<Receiver<u64>>,
         exit_evt: EventFd,
         intc: Arc<Mutex<Gic>>,
+        vcpu_list: Arc<VcpuList>,
     ) -> Result<Self> {
         let (event_sender, event_receiver) = unbounded();
         let (response_sender, response_receiver) = unbounded();
@@ -311,6 +313,7 @@ impl Vcpu {
             response_receiver: Some(response_receiver),
             response_sender,
             intc,
+            vcpu_list,
         })
     }
 
@@ -382,11 +385,7 @@ impl Vcpu {
     /// Returns error or enum specifying whether emulation was handled or interrupted.
     fn run_emulation(&mut self, hvf_vcpu: &mut HvfVcpu) -> Result<VcpuEmulation> {
         let vcpuid = hvf_vcpu.id();
-        let pending_irq = self
-            .intc
-            .lock()
-            .unwrap()
-            .vcpu_has_pending_irq(hvf_vcpu.id());
+        let pending_irq = self.vcpu_list.has_pending_irq(vcpuid);
 
         match hvf_vcpu.run(pending_irq) {
             Ok(exit) => match exit {
@@ -441,7 +440,7 @@ impl Vcpu {
                 }
                 VcpuExit::VtimerActivated => {
                     debug!("vCPU {} VtimerActivated", vcpuid);
-                    self.intc.lock().unwrap().set_vtimer_irq(vcpuid);
+                    self.vcpu_list.set_vtimer_irq(vcpuid);
                     Ok(VcpuEmulation::Handled)
                 }
                 VcpuExit::WaitForEvent => {
@@ -469,10 +468,8 @@ impl Vcpu {
         let hvf_vcpuid = hvf_vcpu.id();
 
         let (wfe_sender, wfe_receiver) = unbounded();
-        self.intc
-            .lock()
-            .unwrap()
-            .register_vcpu(hvf_vcpuid, wfe_sender);
+        self.vcpu_list.register(hvf_vcpuid, wfe_sender);
+        self.intc.lock().unwrap().add_vcpu();
 
         let entry_addr = if let Some(boot_receiver) = &self.boot_receiver {
             boot_receiver.recv().unwrap()
@@ -518,7 +515,7 @@ impl Vcpu {
         receiver: &Receiver<u32>,
         timeout: Option<Duration>,
     ) {
-        if self.intc.lock().unwrap().vcpu_should_wait(hvf_vcpuid) {
+        if self.vcpu_list.should_wait(hvf_vcpuid) {
             if let Some(timeout) = timeout {
                 match receiver.recv_timeout(timeout) {
                     Ok(_) => {}
