libertem-qd-mpx 0.2.13__tar.gz → 0.2.14__tar.gz

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/Cargo.lock

@@ -991,7 +991,7 @@ dependencies = [
 
 [[package]]
 name = "common"
-version = "0.2.13"
+version = "0.2.14"
 dependencies = [
  "bincode",
  "criterion",
@@ -2304,7 +2304,7 @@ checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 
 [[package]]
 name = "libertem-asi-mpx3"
-version = "0.2.13"
+version = "0.2.14"
 dependencies = [
  "bincode",
  "common",
@@ -2325,7 +2325,7 @@ dependencies = [
 
 [[package]]
 name = "libertem-asi-tpx3"
-version = "0.2.13"
+version = "0.2.14"
 dependencies = [
  "bincode",
  "common",
@@ -2341,13 +2341,14 @@ dependencies = [
  "serde",
  "stats",
  "tempfile",
+ "thiserror",
  "uuid",
  "zerocopy",
 ]
 
 [[package]]
 name = "libertem-dectris"
-version = "0.2.13"
+version = "0.2.14"
 dependencies = [
  "bincode",
  "bs_sys",
@@ -2377,7 +2378,7 @@ dependencies = [
 
 [[package]]
 name = "libertem_qd_mpx"
-version = "0.2.13"
+version = "0.2.14"
 dependencies = [
  "bincode",
  "common",
@@ -3900,6 +3901,7 @@ dependencies = [
  "reqwest",
  "serde",
  "serde_json",
+ "thiserror",
  "url",
 ]
 

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: libertem_qd_mpx
-Version: 0.2.13
+Version: 0.2.14
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/common/Cargo.toml

@@ -2,7 +2,7 @@
 name = "common"
 authors = ["Alexander Clausen <a.clausen@fz-juelich.de>"]
 license = "MIT"
-version = "0.2.13"
+version = "0.2.14"
 edition = "2021"
 rust-version = "1.71"
 readme = "README.md"
@@ -35,3 +35,6 @@ criterion = "0.5.1"
 [[bench]]
 name = "casting"
 harness = false
+
+[lints.rust]
+unused_must_use = "deny"

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/common/src/frame_stack.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use ipc_test::{SharedSlabAllocator, SlotForWriting};
+use ipc_test::{slab::ShmError, SharedSlabAllocator, SlotForWriting};
 use log::{error, warn};
 use pyo3::{
     exceptions::{PyRuntimeError, PyValueError},
@@ -45,6 +45,9 @@ pub enum FrameStackWriteError {
 
     #[error("too small")]
     TooSmall,
+
+    #[error("SHM access error: {0}")]
+    ShmAccessError(#[from] ShmError),
 }
 
 impl From<FrameStackWriteError> for PyErr {
@@ -56,6 +59,7 @@ impl From<FrameStackWriteError> for PyErr {
             FrameStackWriteError::TooSmall => {
                 PyValueError::new_err("frame stack too small to handle single frame")
             }
+            FrameStackWriteError::ShmAccessError(e) => PyValueError::new_err(e.to_string()),
         }
     }
 }
@@ -64,6 +68,9 @@ impl From<FrameStackWriteError> for PyErr {
 pub enum SplitError<M: FrameMeta> {
     #[error("shm full")]
     ShmFull(FrameStackHandle<M>),
+
+    #[error("shm access error: {0}")]
+    AccessError(#[from] ShmError),
 }
 
 pub struct FrameStackForWriting<M>
@@ -160,7 +167,7 @@ where
     ) -> Result<FrameStackHandle<M>, FrameStackWriteError> {
         if self.is_empty() {
             let slot_info = shm.writing_done(self.slot);
-            shm.free_idx(slot_info.slot_idx);
+            shm.free_idx(slot_info.slot_idx)?;
             return Err(FrameStackWriteError::Empty);
         }
 
@@ -180,7 +187,7 @@ where
     ) -> Result<(), FrameStackWriteError> {
         if self.is_empty() {
             let slot_info = shm.writing_done(self.slot);
-            shm.free_idx(slot_info.slot_idx);
+            shm.free_idx(slot_info.slot_idx)?;
             Ok(())
         } else {
             Err(FrameStackWriteError::NonEmpty)
@@ -296,15 +303,17 @@ mod inner {
                 let mut slot_left = match shm.try_get_mut() {
                     Ok(s) => s,
                     Err(ShmError::NoSlotAvailable) => return Err(SplitError::ShmFull(self)),
+                    Err(e @ ShmError::MutexError(_)) => return Err(e.into()),
                 };
                 let mut slot_right = match shm.try_get_mut() {
                     Ok(s) => s,
                     Err(ShmError::NoSlotAvailable) => {
                         // don't leak the left slot!
                         let l = shm.writing_done(slot_left);
-                        shm.free_idx(l.slot_idx);
+                        shm.free_idx(l.slot_idx)?;
                         return Err(SplitError::ShmFull(self));
                     }
+                    Err(e @ ShmError::MutexError(_)) => return Err(e.into()),
                 };
 
                 let slice_left = slot_left.as_slice_mut();
@@ -316,7 +325,7 @@ mod inner {
                 let left = shm.writing_done(slot_left);
                 let right = shm.writing_done(slot_right);
 
-                shm.free_idx(self.slot.slot_idx);
+                shm.free_idx(self.slot.slot_idx)?;
 
                 (left, right)
             };
@@ -351,8 +360,8 @@ mod inner {
             f(&slot_r)
         }
 
-        pub fn free_slot(self, shm: &mut SharedSlabAllocator) {
-            shm.free_idx(self.slot.slot_idx);
+        pub fn free_slot(self, shm: &mut SharedSlabAllocator) -> Result<(), ShmError> {
+            shm.free_idx(self.slot.slot_idx)
         }
     }
 
@@ -493,7 +502,7 @@ impl<'b, M: FrameMeta> Drop for WriteGuard<'b, M> {
                 match frame_stack.writing_done(self.shm) {
                     Ok(frame_stack) => {
                         warn!("discarding non-empty frame stack as result of previous errors");
-                        frame_stack.free_slot(self.shm);
+                        let _ = frame_stack.free_slot(self.shm);
                     }
                     Err(e) => error!("WriteGuard::drop failed: {e:?}"),
                 }
@@ -616,12 +625,12 @@ mod tests {
         assert_eq!(a.offsets.len() + b.offsets.len(), 2);
 
         // when the split is done, there should be one free shm slot:
-        assert_eq!(shm.num_slots_free(), 1);
+        assert_eq!(shm.num_slots_free().unwrap(), 1);
 
         // and we can free them again:
-        shm.free_idx(a.slot.slot_idx);
-        shm.free_idx(b.slot.slot_idx);
+        shm.free_idx(a.slot.slot_idx).unwrap();
+        shm.free_idx(b.slot.slot_idx).unwrap();
 
-        assert_eq!(shm.num_slots_free(), 3);
+        assert_eq!(shm.num_slots_free().unwrap(), 3);
     }
 }

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/common/src/generic_cam_client.rs

@@ -1,6 +1,9 @@
 use std::fmt::Debug;
 
-use ipc_test::{slab::SlabInitError, SharedSlabAllocator};
+use ipc_test::{
+    slab::{ShmError, SlabInitError},
+    SharedSlabAllocator,
+};
 use multiversion::multiversion;
 use ndarray::ArrayViewMut3;
 use num::cast::AsPrimitive;
@@ -18,6 +21,9 @@ pub enum CamClientError {
         error: SlabInitError,
     },
 
+    #[error("failed to access SHM: {0}")]
+    ShmError(#[from] ShmError),
+
     #[error("operation on closed client")]
     Closed,
 
@@ -166,7 +172,7 @@ where
         M: FrameMeta,
     {
         let shm = self.get_shm_mut()?;
-        handle.free_slot(shm);
+        handle.free_slot(shm)?;
         Ok(())
     }
 

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/common/src/generic_connection.rs

@@ -6,7 +6,10 @@ use std::{
     time::{Duration, Instant},
 };
 
-use ipc_test::{slab::SlabInitError, SharedSlabAllocator};
+use ipc_test::{
+    slab::{ShmError, SlabInitError},
+    SharedSlabAllocator,
+};
 use log::{debug, info, trace, warn};
 use stats::Stats;
 
@@ -53,6 +56,9 @@ pub enum ConnectionError {
     #[error("could not connect to SHM area: {0}")]
     ShmConnectError(#[from] SlabInitError),
 
+    #[error("could not access SHM")]
+    ShmAccessError(#[from] ShmError),
+
     #[error("background thread is dead")]
     Disconnected,
 
@@ -117,6 +123,7 @@ where
                 frame_stack = old_frame_stack;
                 continue;
             }
+            Err(SplitError::AccessError(e)) => return Err(e.into()),
         };
     }
 }
@@ -314,13 +321,13 @@ where
                     return Err(ConnectionError::FatalError(error))
                 }
                 ReceiverMsg::FrameStack { frame_stack } => {
-                    frame_stack.free_slot(&mut self.shm);
+                    frame_stack.free_slot(&mut self.shm)?;
                     return Err(ConnectionError::UnexpectedMessage(
                         "ReceiverMsg::FrameStack in wait_for_arm".to_owned(),
                     ));
                 }
                 ReceiverMsg::Finished { frame_stack } => {
-                    frame_stack.free_slot(&mut self.shm);
+                    frame_stack.free_slot(&mut self.shm)?;
                     return Err(ConnectionError::UnexpectedMessage(
                         "ReceiverMsg::Finished in wait_for_arm".to_owned(),
                     ));
@@ -406,11 +413,11 @@ where
             match res {
                 ReceiverMsg::FrameStack { frame_stack } => {
                     trace!("wait_for_status: ignoring received FrameStackHandle");
-                    frame_stack.free_slot(&mut self.shm);
+                    frame_stack.free_slot(&mut self.shm)?;
                 }
                 ReceiverMsg::Finished { frame_stack } => {
                     warn!("wait_for_status: ignoring FrameStackHandle received in ReceiverMsg::Finished message");
-                    frame_stack.free_slot(&mut self.shm);
+                    frame_stack.free_slot(&mut self.shm)?;
                 }
                 ReceiverMsg::FatalError { error } => {
                     return Err(ConnectionError::FatalError(error));
@@ -568,12 +575,13 @@ where
         self.wait_for_status(ConnectionStatus::Idle, *timeout, periodic_callback)
     }
 
-    pub fn log_shm_stats(&self) {
+    pub fn log_shm_stats(&self) -> Result<(), ConnectionError> {
         let shm = &self.shm;
-        let free = shm.num_slots_free();
+        let free = shm.num_slots_free()?;
         let total = shm.num_slots_total();
         self.stats.log_stats();
         info!("shm stats free/total: {}/{}", free, total);
+        Ok(())
     }
 
     pub fn reset_stats(&mut self) {

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/common/src/py_connection.rs

@@ -191,7 +191,9 @@ macro_rules! impl_py_connection {
                     let _trace_guard = span_from_py(py, &format!("{}::close", stringify!($name)))?;
 
                     if let Some(mut conn_impl) = self.conn_impl.take() {
-                        conn_impl.log_shm_stats();
+                        conn_impl
+                            .log_shm_stats()
+                            .map_err(|e| PyConnectionError::new_err(e.to_string()))?;
                         conn_impl.reset_stats();
                         conn_impl.close();
                         Ok(())
@@ -261,7 +263,9 @@ macro_rules! impl_py_connection {
 
                 pub fn log_shm_stats(&self) -> PyResult<()> {
                     let conn_impl = self.get_conn()?;
-                    conn_impl.log_shm_stats();
+                    conn_impl
+                        .log_shm_stats()
+                        .map_err(|e| PyConnectionError::new_err(e.to_string()))?;
                     Ok(())
                 }
             }

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/ipc_test/Cargo.toml

@@ -30,3 +30,6 @@ sendfd = "0.4.3"
 
 [target.'cfg(not(windows))'.dependencies]
 nix = { version = "0.29.0", features = ["poll"] }
+
+[lints.rust]
+unused_must_use = "deny"

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/ipc_test/examples/consumer/main.rs

@@ -75,13 +75,13 @@ fn main() {
         // some additional "work":
         //std::thread::sleep(Duration::from_micros(1));
 
-        ssa.free_idx(slot_info.slot_idx);
+        ssa.free_idx(slot_info.slot_idx).unwrap();
 
         sum += sum_part.0 as f64;
         bytes_processed += SLOT_SIZE_BYTES;
 
         if t0.elapsed() > Duration::from_secs(1) {
-            let slots_free = ssa.num_slots_free();
+            let slots_free = ssa.num_slots_free().unwrap();
             println!(
                 "idx: {idx:5}, sum: {sum_part}, throughput: {:7.2} MiB/s, slots free: {slots_free}",
                 bytes_processed as f32 / 1024.0 / 1024.0

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/ipc_test/examples/producer/main.rs

@@ -70,7 +70,7 @@ fn handle_connection(
     }
 
     println!("done sending {} items", send_num_items);
-    while ssa.num_slots_free() < ssa.num_slots_total() {
+    while ssa.num_slots_free().unwrap() < ssa.num_slots_total() {
         thread::sleep(Duration::from_millis(100));
     }
     println!("done!")

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/ipc_test/src/backend_shm.rs

@@ -111,7 +111,7 @@ impl SharedMemory {
 impl Drop for SharedMemory {
     fn drop(&mut self) {
         if self.is_owner {
-            remove_file(&self.handle_path).unwrap();
+            let _ = remove_file(&self.handle_path);
         }
     }
 }

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/ipc_test/src/slab.rs

@@ -69,10 +69,13 @@ pub struct SHMHandle {
 
 impl SHMHandle {}
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, Clone, thiserror::Error)]
 pub enum ShmError {
     #[error("no slot available")]
     NoSlotAvailable,
+
+    #[error("mutex error: {0}")]
+    MutexError(String),
 }
 
 /// Additional information needed to re-crate a `SharedSlabAllocator` in a
@@ -103,6 +106,9 @@ pub struct SharedSlabAllocator {
 pub enum SlabInitError {
     #[error("connection failed: {0}")]
     ConnectError(#[from] ShmConnectError),
+
+    #[error("mutex error: {0}")]
+    MutexError(String),
 }
 
 ///
@@ -185,7 +191,8 @@ impl SharedSlabAllocator {
         let free_list_ptr = unsafe { ptr.offset(Self::MUTEX_SIZE.try_into().unwrap()) };
 
         let (_lock, bg_thread) = if init_structures {
-            let (lock, used_size) = unsafe { Mutex::new(ptr, free_list_ptr).unwrap() };
+            let (lock, used_size) = unsafe { Mutex::new(ptr, free_list_ptr) }
+                .map_err(|e| SlabInitError::MutexError(e.to_string()))?;
 
             if used_size > Self::MUTEX_SIZE {
                 panic!("Mutex size larger than expected!");
@@ -231,7 +238,8 @@ impl SharedSlabAllocator {
 
             (lock, Some((j, cleanup_chan_s)))
         } else {
-            let (lock, used_size) = unsafe { Mutex::from_existing(ptr, free_list_ptr).unwrap() };
+            let (lock, used_size) = unsafe { Mutex::from_existing(ptr, free_list_ptr) }
+                .map_err(|e| SlabInitError::MutexError(e.to_string()))?;
 
             if used_size > Self::MUTEX_SIZE {
                 panic!("Mutex size larger than expected!");
@@ -259,11 +267,12 @@ impl SharedSlabAllocator {
         Self::connect(&handle.os_handle)
     }
 
-    fn get_mutex(&self) -> Box<dyn LockImpl> {
+    fn get_mutex(&self) -> Result<Box<dyn LockImpl>, ShmError> {
         let ptr = self.shm.as_mut_ptr();
         let free_list_ptr = unsafe { ptr.offset(Self::MUTEX_SIZE.try_into().unwrap()) };
-        let (lock, _) = unsafe { Mutex::from_existing(ptr, free_list_ptr).unwrap() };
-        lock
+        let (lock, _) = unsafe { Mutex::from_existing(ptr, free_list_ptr) }
+            .map_err(|e| ShmError::MutexError(e.to_string()))?;
+        Ok(lock)
     }
 
     pub fn get_slab_info(&self) -> SlabInfo {
@@ -290,19 +299,27 @@ impl SharedSlabAllocator {
     /// `SlotInfo` struct using `writing_done`, which can then be sent to
     /// a consumer.
     pub fn get_mut(&mut self) -> Option<SlotForWriting> {
-        let slot_idx: usize = self.pop_free_slot_idx()?;
+        match self.try_get_mut() {
+            Ok(slot) => Some(slot),
+            Err(_) => None,
+        }
+    }
 
-        Some(SlotForWriting {
+    pub fn try_get_mut(&mut self) -> Result<SlotForWriting, ShmError> {
+        let slot_idx: usize = match self.pop_free_slot_idx()? {
+            Some(idx) => idx,
+            None => {
+                return Err(ShmError::NoSlotAvailable);
+            }
+        };
+
+        Ok(SlotForWriting {
             ptr: self.get_mut_ptr_for_slot(slot_idx),
             slot_idx,
             size: self.slot_size,
         })
     }
 
-    pub fn try_get_mut(&mut self) -> Result<SlotForWriting, ShmError> {
-        self.get_mut().ok_or(ShmError::NoSlotAvailable)
-    }
-
     /// Exchange the `SlotForWriting` token into
     /// a `SlotInfo` that can be sent to readers
     /// which can not be used to write anymore
@@ -314,11 +331,11 @@ impl SharedSlabAllocator {
         }
     }
 
-    pub fn num_slots_free(&self) -> usize {
-        let mutex = self.get_mutex();
+    pub fn num_slots_free(&self) -> Result<usize, ShmError> {
+        let mutex = self.get_mutex()?;
         let guard = mutex.lock().unwrap();
         let stack = Self::get_free_list(*guard, self.num_slots);
-        stack.get_stack_idx()
+        Ok(stack.get_stack_idx())
     }
 
     pub fn num_slots_total(&self) -> usize {
@@ -338,11 +355,12 @@ impl SharedSlabAllocator {
         }
     }
 
-    pub fn free_idx(&mut self, slot_idx: usize) {
-        let mutex = self.get_mutex();
+    pub fn free_idx(&mut self, slot_idx: usize) -> Result<(), ShmError> {
+        let mutex = self.get_mutex()?;
         let guard = mutex.lock().unwrap();
         let mut stack = Self::get_free_list(*guard, self.num_slots);
         stack.push(slot_idx);
+        Ok(())
     }
 
     ///
@@ -416,11 +434,11 @@ impl SharedSlabAllocator {
         FreeStack::new(stack_ptr, free_list_size)
     }
 
-    fn pop_free_slot_idx(&mut self) -> Option<usize> {
-        let mutex = self.get_mutex();
+    fn pop_free_slot_idx(&mut self) -> Result<Option<usize>, ShmError> {
+        let mutex = self.get_mutex()?;
         let guard = mutex.lock().unwrap();
         let mut stack = Self::get_free_list(*guard, self.num_slots);
-        stack.pop()
+        Ok(stack.pop())
     }
 }
 
@@ -477,7 +495,7 @@ mod test {
         for i in 0..255u8 {
             assert_eq!(slotr.as_slice()[i as usize], i);
         }
-        ssa.free_idx(slotw.slot_idx);
+        ssa.free_idx(slotw.slot_idx).unwrap();
     }
 
     #[test]
@@ -505,7 +523,7 @@ mod test {
         for i in 0..255u8 {
             assert_eq!(slotr.as_slice()[i as usize], i);
         }
-        ssa2.free_idx(slotw.slot_idx);
+        ssa2.free_idx(slotw.slot_idx).unwrap();
     }
 
     #[test]
@@ -534,7 +552,7 @@ mod test {
         for i in 0..255u8 {
             assert_eq!(slotr.as_slice()[i as usize], i);
         }
-        ssa2.free_idx(slotw.slot_idx);
+        ssa2.free_idx(slotw.slot_idx).unwrap();
     }
 
     #[test]
@@ -575,7 +593,7 @@ mod test {
 
                 // We are done with the data in the slot, make it available
                 // to the producer:
-                ssa2.free_idx(idx);
+                ssa2.free_idx(idx).unwrap();
 
                 // for keeping the test robust: signal main thread we are done
                 done_s.send(()).unwrap();

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/libertem_qd_mpx/Cargo.toml

@@ -2,7 +2,7 @@
 name = "libertem_qd_mpx"
 authors = ["Alexander Clausen <a.clausen@fz-juelich.de>"]
 license = "MIT"
-version = "0.2.13"
+version = "0.2.14"
 edition = "2021"
 readme = "README.md"
 rust-version = "1.71"
@@ -41,3 +41,6 @@ tokio = { version = "1", features = ["rt", "net", "time", "sync", "io-util", "rt
 [[bench]]
 name = "decoders"
 harness = false
+
+[lints.rust]
+unused_must_use = "deny"

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/libertem_qd_mpx/src/background_thread.rs

@@ -49,8 +49,8 @@ pub enum AcquisitionError {
     #[error("configuration error: {msg}")]
     ConfigurationError { msg: String },
 
-    #[error("shm buffer full")]
-    NoSlotAvailable,
+    #[error("error accessing shm: {0}")]
+    ShmAccessError(#[from] ShmError),
 
     #[error("error writing to shm: {0}")]
     WriteError(#[from] FrameStackWriteError),
@@ -95,14 +95,6 @@ impl<T> From<SendError<T>> for AcquisitionError {
     }
 }
 
-impl From<ShmError> for AcquisitionError {
-    fn from(value: ShmError) -> Self {
-        match value {
-            ShmError::NoSlotAvailable => AcquisitionError::NoSlotAvailable,
-        }
-    }
-}
-
 impl From<ReadExactError<AcquisitionError>> for AcquisitionError {
     fn from(value: ReadExactError<AcquisitionError>) -> Self {
         match value {
@@ -370,7 +362,7 @@ fn make_frame_stack<'a>(
 ) -> Result<WriteGuard<'a, QdFrameMeta>, AcquisitionError> {
     loop {
         // keep some slots free for splitting frame stacks
-        if shm.num_slots_free() < 3 && shm.num_slots_total() >= 3 {
+        if shm.num_slots_free()? < 3 && shm.num_slots_total() >= 3 {
             trace!("shm is almost full; waiting and creating backpressure...");
             check_for_control(to_thread_r)?;
             std::thread::sleep(Duration::from_millis(1));
@@ -394,6 +386,9 @@ fn make_frame_stack<'a>(
                 std::thread::sleep(Duration::from_millis(1));
                 continue;
             }
+            Err(e @ ShmError::MutexError(_)) => {
+                return Err(e.into());
+            }
         }
     }
 }
@@ -624,7 +619,7 @@ fn passive_acquisition(
             shm,
         )?;
 
-        let free = shm.num_slots_free();
+        let free = shm.num_slots_free()?;
         let total = shm.num_slots_total();
         info!("passive acquisition done; free slots: {}/{}", free, total);
 
@@ -974,7 +969,7 @@ End
             conn.close();
             server_thread.join().unwrap();
 
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1051,7 +1046,7 @@ End
             conn.close();
             server_thread.join().unwrap();
 
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1156,7 +1151,7 @@ End
                     stack.with_slot(&shm, |s| {
                         assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                     });
-                    stack.free_slot(&mut shm);
+                    stack.free_slot(&mut shm).unwrap();
                     idx += 1;
                 } else {
                     eprintln!("done!");
@@ -1173,7 +1168,7 @@ End
             conn.close();
             server_thread.join().unwrap();
 
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1257,7 +1252,7 @@ End
                     stack.with_slot(&shm, |s| {
                         assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                     });
-                    stack.free_slot(&mut shm);
+                    stack.free_slot(&mut shm).unwrap();
                 } else {
                     eprintln!("done!");
                     break;
@@ -1272,7 +1267,7 @@ End
             conn.close();
             server_thread.join().unwrap();
 
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1365,7 +1360,7 @@ End
                     stack.with_slot(&shm, |s| {
                         assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                     });
-                    stack.free_slot(&mut shm);
+                    stack.free_slot(&mut shm).unwrap();
                 } else {
                     eprintln!("done!");
                     break;
@@ -1380,7 +1375,7 @@ End
             conn.close();
             server_thread.join().unwrap();
 
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1478,7 +1473,7 @@ End
                     stack.with_slot(&shm, |s| {
                         assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                     });
-                    stack.free_slot(&mut shm);
+                    stack.free_slot(&mut shm).unwrap();
                 } else {
                     eprintln!("done!");
                     break;
@@ -1493,7 +1488,7 @@ End
             conn.close();
             server_thread.join().unwrap();
 
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1586,7 +1581,7 @@ End
                 stack.with_slot(&shm, |s| {
                     assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                 });
-                stack.free_slot(&mut shm);
+                stack.free_slot(&mut shm).unwrap();
             }
 
             let next = conn.get_next_stack(1, || Ok::<_, std::io::Error>(()));
@@ -1601,7 +1596,7 @@ End
             server_thread.join().unwrap();
 
             // we don't leak any slots, yay!
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1690,7 +1685,7 @@ End
                 stack.with_slot(&shm, |s| {
                     assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                 });
-                stack.free_slot(&mut shm);
+                stack.free_slot(&mut shm).unwrap();
                 idx += 1;
 
                 if Instant::now() > deadline {
@@ -1820,7 +1815,7 @@ End
             first.with_slot(&shm, |s| {
                 assert_eq!(s.as_slice(), vec![0u8; 256 * 256],);
             });
-            first.free_slot(&mut shm);
+            first.free_slot(&mut shm).unwrap();
 
             info!("got the first one");
 
@@ -1848,7 +1843,7 @@ End
                 stack.with_slot(&shm, |s| {
                     assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                 });
-                stack.free_slot(&mut shm);
+                stack.free_slot(&mut shm).unwrap();
             }
 
             // allow the server thread to end:
@@ -1859,7 +1854,7 @@ End
             server_thread.join().unwrap();
 
             // we don't leak any slots, yay!
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 
@@ -1970,7 +1965,7 @@ End
                 stack.with_slot(&shm, |s| {
                     assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                 });
-                stack.free_slot(&mut shm);
+                stack.free_slot(&mut shm).unwrap();
             }
 
             // next stack is an error:
@@ -2001,7 +1996,7 @@ End
                 stack.with_slot(&shm, |s| {
                     assert_eq!(s.as_slice(), vec![idx as u8; 256 * 256],);
                 });
-                stack.free_slot(&mut shm);
+                stack.free_slot(&mut shm).unwrap();
             }
 
             // that was the last stack:
@@ -2022,7 +2017,7 @@ End
                 .expect("server should be able to send everything");
 
             // we don't leak any slots, yay!
-            assert_eq!(shm.num_slots_total(), shm.num_slots_free());
+            assert_eq!(shm.num_slots_total(), shm.num_slots_free().unwrap());
         });
     }
 }

{libertem_qd_mpx-0.2.13 → libertem_qd_mpx-0.2.14}/stats/Cargo.toml

@@ -10,3 +10,6 @@ rust-version = "1.71"
 
 [dependencies]
 log = "0.4.22"
+
+[lints.rust]
+unused_must_use = "deny"