Merge pull request 'prepare MIB release' (#109) from mib-v0.1.0-alpha.2 into main

Reviewed-on: #109

satrs-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-core"
-version = "0.1.0-alpha.2"
+version = "0.1.0-alpha.3"
 edition = "2021"
 rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]

satrs-core/src/pool.rs

@@ -1,12 +1,19 @@
 //! # Pool implementation providing memory pools for packet storage.
 //!
+//! This module provides generic abstractions for memory pools which provide a storage
+//! machanism for variable sized data like Telemetry and Telecommand (TMTC) packets. The core
+//! abstraction for this is the [PoolProvider] trait.
+//!
+//! It also contains the [StaticMemoryPool] as a concrete implementation which can be used to avoid
+//! dynamic run-time allocations for the storage of TMTC packets.
+//!
 //! # Example for the [StaticMemoryPool]
 //!
 //! ```
 //! use satrs_core::pool::{PoolProvider, StaticMemoryPool, StaticPoolConfig};
 //!
 //! // 4 buckets of 4 bytes, 2 of 8 bytes and 1 of 16 bytes
-//! let pool_cfg = StaticPoolConfig::new(vec![(4, 4), (2, 8), (1, 16)]);
+//! let pool_cfg = StaticPoolConfig::new(vec![(4, 4), (2, 8), (1, 16)], false);
 //! let mut local_pool = StaticMemoryPool::new(pool_cfg);
 //! let mut read_buf: [u8; 16] = [0; 16];
 //! let mut addr;
@@ -369,16 +376,24 @@ mod alloc_mod {
     ///
     /// # Parameters
     ///
-    /// * `cfg`: Vector of tuples which represent a subpool. The first entry in the tuple specifies the
-    ///       number of memory blocks in the subpool, the second entry the size of the blocks
+    /// * `cfg` - Vector of tuples which represent a subpool. The first entry in the tuple specifies
+    ///     the number of memory blocks in the subpool, the second entry the size of the blocks
+    /// * `spill_to_higher_subpools` - Specifies whether data will be spilled to higher subpools
+    ///     if the next fitting subpool is full. This is useful to ensure the pool remains useful
+    ///     for all data sizes as long as possible. However, an undesirable side-effect might be
+    ///     the chocking of larger subpools by underdimensioned smaller subpools.
     #[derive(Clone)]
     pub struct StaticPoolConfig {
         cfg: Vec<(NumBlocks, usize)>,
+        spill_to_higher_subpools: bool,
     }
 
     impl StaticPoolConfig {
-        pub fn new(cfg: Vec<(NumBlocks, usize)>) -> Self {
-            StaticPoolConfig { cfg }
+        pub fn new(cfg: Vec<(NumBlocks, usize)>, spill_to_higher_subpools: bool) -> Self {
+            StaticPoolConfig {
+                cfg,
+                spill_to_higher_subpools,
+            }
         }
 
         pub fn cfg(&self) -> &Vec<(NumBlocks, usize)> {
@@ -467,7 +482,17 @@ mod alloc_mod {
         }
 
         fn reserve(&mut self, data_len: usize) -> Result<StaticPoolAddr, StoreError> {
-            let subpool_idx = self.find_subpool(data_len, 0)?;
+            let mut subpool_idx = self.find_subpool(data_len, 0)?;
+
+            if self.pool_cfg.spill_to_higher_subpools {
+                while let Err(StoreError::StoreFull(_)) = self.find_empty(subpool_idx) {
+                    if (subpool_idx + 1) as usize == self.sizes_lists.len() {
+                        return Err(StoreError::StoreFull(subpool_idx));
+                    }
+                    subpool_idx += 1;
+                }
+            }
+
             let (slot, size_slot_ref) = self.find_empty(subpool_idx)?;
             *size_slot_ref = data_len;
             Ok(StaticPoolAddr {
@@ -639,22 +664,22 @@ mod tests {
 
     fn basic_small_pool() -> StaticMemoryPool {
         // 4 buckets of 4 bytes, 2 of 8 bytes and 1 of 16 bytes
-        let pool_cfg = StaticPoolConfig::new(vec![(4, 4), (2, 8), (1, 16)]);
+        let pool_cfg = StaticPoolConfig::new(vec![(4, 4), (2, 8), (1, 16)], false);
         StaticMemoryPool::new(pool_cfg)
     }
 
     #[test]
     fn test_cfg() {
         // Values where number of buckets is 0 or size is too large should be removed
-        let mut pool_cfg = StaticPoolConfig::new(vec![(0, 0), (1, 0), (2, POOL_MAX_SIZE)]);
+        let mut pool_cfg = StaticPoolConfig::new(vec![(0, 0), (1, 0), (2, POOL_MAX_SIZE)], false);
         pool_cfg.sanitize();
         assert_eq!(*pool_cfg.cfg(), vec![(1, 0)]);
         // Entries should be ordered according to bucket size
-        pool_cfg = StaticPoolConfig::new(vec![(16, 6), (32, 3), (8, 12)]);
+        pool_cfg = StaticPoolConfig::new(vec![(16, 6), (32, 3), (8, 12)], false);
         pool_cfg.sanitize();
         assert_eq!(*pool_cfg.cfg(), vec![(32, 3), (16, 6), (8, 12)]);
         // Unstable sort is used, so order of entries with same block length should not matter
-        pool_cfg = StaticPoolConfig::new(vec![(12, 12), (14, 16), (10, 12)]);
+        pool_cfg = StaticPoolConfig::new(vec![(12, 12), (14, 16), (10, 12)], false);
         pool_cfg.sanitize();
         assert!(
             *pool_cfg.cfg() == vec![(12, 12), (10, 12), (14, 16)]
@@ -947,4 +972,72 @@ mod tests {
             })
             .expect("Modifying data failed");
     }
+
+    #[test]
+    fn test_spills_to_higher_subpools() {
+        let pool_cfg = StaticPoolConfig::new(vec![(2, 8), (2, 16)], true);
+        let mut local_pool = StaticMemoryPool::new(pool_cfg);
+        local_pool.free_element(8, |_| {}).unwrap();
+        local_pool.free_element(8, |_| {}).unwrap();
+        let mut in_larger_subpool_now = local_pool.free_element(8, |_| {});
+        assert!(in_larger_subpool_now.is_ok());
+        let generic_addr = in_larger_subpool_now.unwrap();
+        let pool_addr = StaticPoolAddr::from(generic_addr);
+        assert_eq!(pool_addr.pool_idx, 1);
+        assert_eq!(pool_addr.packet_idx, 0);
+        assert!(local_pool.has_element_at(&generic_addr).unwrap());
+        in_larger_subpool_now = local_pool.free_element(8, |_| {});
+        assert!(in_larger_subpool_now.is_ok());
+        let generic_addr = in_larger_subpool_now.unwrap();
+        let pool_addr = StaticPoolAddr::from(generic_addr);
+        assert_eq!(pool_addr.pool_idx, 1);
+        assert_eq!(pool_addr.packet_idx, 1);
+        assert!(local_pool.has_element_at(&generic_addr).unwrap());
+    }
+
+    #[test]
+    fn test_spillage_fails_as_well() {
+        let pool_cfg = StaticPoolConfig::new(vec![(1, 8), (1, 16)], true);
+        let mut local_pool = StaticMemoryPool::new(pool_cfg);
+        local_pool.free_element(8, |_| {}).unwrap();
+        local_pool.free_element(8, |_| {}).unwrap();
+        let should_fail = local_pool.free_element(8, |_| {});
+        assert!(should_fail.is_err());
+        if let Err(err) = should_fail {
+            assert_eq!(err, StoreError::StoreFull(1));
+        } else {
+            panic!("unexpected store address");
+        }
+    }
+
+    #[test]
+    fn test_spillage_works_across_multiple_subpools() {
+        let pool_cfg = StaticPoolConfig::new(vec![(1, 8), (1, 12), (1, 16)], true);
+        let mut local_pool = StaticMemoryPool::new(pool_cfg);
+        local_pool.free_element(8, |_| {}).unwrap();
+        local_pool.free_element(12, |_| {}).unwrap();
+        let in_larger_subpool_now = local_pool.free_element(8, |_| {});
+        assert!(in_larger_subpool_now.is_ok());
+        let generic_addr = in_larger_subpool_now.unwrap();
+        let pool_addr = StaticPoolAddr::from(generic_addr);
+        assert_eq!(pool_addr.pool_idx, 2);
+        assert_eq!(pool_addr.packet_idx, 0);
+        assert!(local_pool.has_element_at(&generic_addr).unwrap());
+    }
+
+    #[test]
+    fn test_spillage_fails_across_multiple_subpools() {
+        let pool_cfg = StaticPoolConfig::new(vec![(1, 8), (1, 12), (1, 16)], true);
+        let mut local_pool = StaticMemoryPool::new(pool_cfg);
+        local_pool.free_element(8, |_| {}).unwrap();
+        local_pool.free_element(12, |_| {}).unwrap();
+        local_pool.free_element(16, |_| {}).unwrap();
+        let should_fail = local_pool.free_element(8, |_| {});
+        assert!(should_fail.is_err());
+        if let Err(err) = should_fail {
+            assert_eq!(err, StoreError::StoreFull(2));
+        } else {
+            panic!("unexpected store address");
+        }
+    }
 }

satrs-core/src/pus/mod.rs

@@ -1017,7 +1017,7 @@ pub mod tests {
         ///
         /// The PUS service handler is instantiated with a [EcssTcInStoreConverter].
         pub fn new() -> (Self, PusServiceHelper<EcssTcInSharedStoreConverter>) {
-            let pool_cfg = StaticPoolConfig::new(vec![(16, 16), (8, 32), (4, 64)]);
+            let pool_cfg = StaticPoolConfig::new(vec![(16, 16), (8, 32), (4, 64)], false);
             let tc_pool = StaticMemoryPool::new(pool_cfg.clone());
             let tm_pool = StaticMemoryPool::new(pool_cfg);
             let shared_tc_pool = SharedStaticMemoryPool::new(RwLock::new(tc_pool));

satrs-core/src/pus/scheduler.rs

@@ -238,7 +238,8 @@ impl Error for ScheduleError {
     }
 }
 
-pub trait PusSchedulerInterface {
+/// Generic trait for scheduler objects which are able to schedule ECSS PUS C packets.
+pub trait PusSchedulerProvider {
     type TimeProvider: CcsdsTimeProvider + TimeReader;
 
     fn reset(&mut self, store: &mut (impl PoolProvider + ?Sized)) -> Result<(), StoreError>;
@@ -782,7 +783,7 @@ pub mod alloc_mod {
         }
     }
 
-    impl PusSchedulerInterface for PusScheduler {
+    impl PusSchedulerProvider for PusScheduler {
         type TimeProvider = cds::TimeProvider;
 
         /// This will disable the scheduler and clear the schedule as specified in 6.11.4.4.
@@ -945,7 +946,7 @@ mod tests {
 
     #[test]
     fn test_reset() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
@@ -1097,7 +1098,7 @@ mod tests {
     }
     #[test]
     fn test_release_telecommands() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
@@ -1163,7 +1164,7 @@ mod tests {
 
     #[test]
     fn release_multi_with_same_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
@@ -1221,7 +1222,7 @@ mod tests {
 
     #[test]
     fn release_with_scheduler_disabled() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
@@ -1291,7 +1292,7 @@ mod tests {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut buf: [u8; 32] = [0; 32];
         let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, None);
 
@@ -1339,7 +1340,7 @@ mod tests {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
 
         let mut buf: [u8; 32] = [0; 32];
         let tc = scheduled_tc(UnixTimestamp::new_only_seconds(100), &mut buf);
@@ -1389,7 +1390,7 @@ mod tests {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
 
         let mut buf: [u8; 32] = [0; 32];
         let tc = wrong_tc_service(UnixTimestamp::new_only_seconds(100), &mut buf);
@@ -1412,7 +1413,7 @@ mod tests {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
 
         let mut buf: [u8; 32] = [0; 32];
         let tc = wrong_tc_subservice(UnixTimestamp::new_only_seconds(100), &mut buf);
@@ -1434,7 +1435,7 @@ mod tests {
     fn insert_wrapped_tc_faulty_app_data() {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let tc = invalid_time_tagged_cmd();
         let insert_res = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
         assert!(insert_res.is_err());
@@ -1449,7 +1450,7 @@ mod tests {
     fn insert_doubly_wrapped_time_tagged_cmd() {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut buf: [u8; 64] = [0; 64];
         let tc = double_wrapped_time_tagged_tc(UnixTimestamp::new_only_seconds(50), &mut buf);
         let insert_res = scheduler.insert_wrapped_tc::<cds::TimeProvider>(&tc, &mut pool);
@@ -1485,7 +1486,7 @@ mod tests {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
 
         let mut buf: [u8; 32] = [0; 32];
 
@@ -1509,7 +1510,7 @@ mod tests {
 
     #[test]
     fn test_store_error_propagation_release() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
@@ -1544,7 +1545,7 @@ mod tests {
 
     #[test]
     fn test_store_error_propagation_reset() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
@@ -1568,7 +1569,7 @@ mod tests {
 
     #[test]
     fn test_delete_by_req_id_simple_retrieve_addr() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
@@ -1587,7 +1588,7 @@ mod tests {
 
     #[test]
     fn test_delete_by_req_id_simple_delete_all() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
@@ -1606,7 +1607,7 @@ mod tests {
 
     #[test]
     fn test_delete_by_req_id_complex() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
@@ -1653,7 +1654,7 @@ mod tests {
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(1, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(1, 64)], false));
 
         let mut buf: [u8; 32] = [0; 32];
         // Store is full after this.
@@ -1692,7 +1693,7 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_all() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1723,7 +1724,7 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_from_stamp() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1754,7 +1755,7 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_to_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1785,7 +1786,7 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_from_time_to_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1820,7 +1821,7 @@ mod tests {
 
     #[test]
     fn test_deletion_all() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1847,7 +1848,7 @@ mod tests {
 
     #[test]
     fn test_deletion_from_start_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1868,7 +1869,7 @@ mod tests {
 
     #[test]
     fn test_deletion_to_end_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1890,7 +1891,7 @@ mod tests {
 
     #[test]
     fn test_deletion_from_start_time_to_end_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
         let cmd_out_of_range_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
@@ -1919,7 +1920,7 @@ mod tests {
 
     #[test]
     fn test_release_without_deletion() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)]));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
         let mut scheduler =
             PusScheduler::new(UnixTimestamp::new_only_seconds(0), Duration::from_secs(5));
 

satrs-core/src/pus/scheduler_srv.rs

@@ -1,4 +1,4 @@
-use super::scheduler::PusSchedulerInterface;
+use super::scheduler::PusSchedulerProvider;
 use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 use crate::pool::PoolProvider;
 use crate::pus::{PusPacketHandlerResult, PusPacketHandlingError};
@@ -16,13 +16,13 @@ use spacepackets::time::cds::TimeProvider;
 /// telecommands when applicable.
 pub struct PusService11SchedHandler<
     TcInMemConverter: EcssTcInMemConverter,
-    Scheduler: PusSchedulerInterface,
+    PusScheduler: PusSchedulerProvider,
 > {
     pub service_helper: PusServiceHelper<TcInMemConverter>,
-    scheduler: Scheduler,
+    scheduler: PusScheduler,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerInterface>
+impl<TcInMemConverter: EcssTcInMemConverter, Scheduler: PusSchedulerProvider>
     PusService11SchedHandler<TcInMemConverter, Scheduler>
 {
     pub fn new(service_helper: PusServiceHelper<TcInMemConverter>, scheduler: Scheduler) -> Self {
@@ -173,7 +173,7 @@ mod tests {
     use crate::pool::{StaticMemoryPool, StaticPoolConfig};
     use crate::pus::tests::TEST_APID;
     use crate::pus::{
-        scheduler::{self, PusSchedulerInterface, TcInfo},
+        scheduler::{self, PusSchedulerProvider, TcInfo},
         tests::{PusServiceHandlerWithSharedStoreCommon, PusTestHarness},
         verification::{RequestId, TcStateAccepted, VerificationToken},
         EcssTcInSharedStoreConverter,
@@ -201,7 +201,7 @@ mod tests {
     impl Pus11HandlerWithStoreTester {
         pub fn new() -> Self {
             let test_scheduler = TestScheduler::default();
-            let pool_cfg = StaticPoolConfig::new(alloc::vec![(16, 16), (8, 32), (4, 64)]);
+            let pool_cfg = StaticPoolConfig::new(alloc::vec![(16, 16), (8, 32), (4, 64)], false);
             let sched_tc_pool = StaticMemoryPool::new(pool_cfg.clone());
             let (common, srv_handler) = PusServiceHandlerWithSharedStoreCommon::new();
             Self {
@@ -232,7 +232,7 @@ mod tests {
         inserted_tcs: VecDeque<TcInfo>,
     }
 
-    impl PusSchedulerInterface for TestScheduler {
+    impl PusSchedulerProvider for TestScheduler {
         type TimeProvider = cds::TimeProvider;
 
         fn reset(

satrs-core/src/pus/verification.rs

@@ -28,7 +28,7 @@
 //! const EMPTY_STAMP: [u8; 7] = [0; 7];
 //! const TEST_APID: u16 = 0x02;
 //!
-//! let pool_cfg = StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
+//! let pool_cfg = StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)], false);
 //! let tm_pool = StaticMemoryPool::new(pool_cfg.clone());
 //! let shared_tm_store = SharedTmPool::new(tm_pool);
 //! let tm_store = shared_tm_store.clone_backing_pool();
@@ -1484,7 +1484,7 @@ mod tests {
 
     #[test]
     fn test_mpsc_verif_send_sync() {
-        let pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(8, 8)]));
+        let pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(8, 8)], false));
         let shared_tm_store = SharedTmPool::new(pool);
         let (tx, _) = mpsc::channel();
         let mpsc_verif_sender =
@@ -2135,9 +2135,9 @@ mod tests {
     }
 
     #[test]
-    // TODO: maybe a bit more extensive testing, all I have time for right now
     fn test_seq_count_increment() {
-        let pool_cfg = StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
+        let pool_cfg =
+            StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)], false);
         let tm_pool = StaticMemoryPool::new(pool_cfg.clone());
         let shared_tm_store = SharedTmPool::new(tm_pool);
         let shared_tm_pool = shared_tm_store.clone_backing_pool();

satrs-core/tests/pools.rs

@@ -9,7 +9,7 @@ const DUMMY_DATA: [u8; 4] = [0, 1, 2, 3];
 
 #[test]
 fn threaded_usage() {
-    let pool_cfg = StaticPoolConfig::new(vec![(16, 6), (32, 3), (8, 12)]);
+    let pool_cfg = StaticPoolConfig::new(vec![(16, 6), (32, 3), (8, 12)], false);
     let shared_pool = Arc::new(RwLock::new(StaticMemoryPool::new(pool_cfg)));
     let shared_clone = shared_pool.clone();
     let (tx, rx): (Sender<StoreAddr>, Receiver<StoreAddr>) = mpsc::channel();

satrs-core/tests/pus_verification.rs

@@ -35,7 +35,8 @@ pub mod crossbeam_test {
         // each reporter have an own sequence count provider.
         let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
         // Shared pool object to store the verification PUS telemetry
-        let pool_cfg = StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)]);
+        let pool_cfg =
+            StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)], false);
         let shared_tm_pool = SharedTmPool::new(StaticMemoryPool::new(pool_cfg.clone()));
         let shared_tc_pool_0 = Arc::new(RwLock::new(StaticMemoryPool::new(pool_cfg)));
         let shared_tc_pool_1 = shared_tc_pool_0.clone();

satrs-example/src/config.rs

@@ -103,34 +103,43 @@ pub mod pool {
     use super::*;
     pub fn create_static_pools() -> (StaticMemoryPool, StaticMemoryPool) {
         (
-            StaticMemoryPool::new(StaticPoolConfig::new(vec![
-                (30, 32),
-                (15, 64),
-                (15, 128),
-                (15, 256),
-                (15, 1024),
-                (15, 2048),
-            ])),
-            StaticMemoryPool::new(StaticPoolConfig::new(vec![
-                (30, 32),
-                (15, 64),
-                (15, 128),
-                (15, 256),
-                (15, 1024),
-                (15, 2048),
-            ])),
+            StaticMemoryPool::new(StaticPoolConfig::new(
+                vec![
+                    (30, 32),
+                    (15, 64),
+                    (15, 128),
+                    (15, 256),
+                    (15, 1024),
+                    (15, 2048),
+                ],
+                true,
+            )),
+            StaticMemoryPool::new(StaticPoolConfig::new(
+                vec![
+                    (30, 32),
+                    (15, 64),
+                    (15, 128),
+                    (15, 256),
+                    (15, 1024),
+                    (15, 2048),
+                ],
+                true,
+            )),
         )
     }
 
     pub fn create_sched_tc_pool() -> StaticMemoryPool {
-        StaticMemoryPool::new(StaticPoolConfig::new(vec![
-            (30, 32),
-            (15, 64),
-            (15, 128),
-            (15, 256),
-            (15, 1024),
-            (15, 2048),
-        ]))
+        StaticMemoryPool::new(StaticPoolConfig::new(
+            vec![
+                (30, 32),
+                (15, 64),
+                (15, 128),
+                (15, 256),
+                (15, 1024),
+                (15, 2048),
+            ],
+            true,
+        ))
     }
 }
 

satrs-mib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib"
-version = "0.1.0-alpha.1"
+version = "0.1.0-alpha.2"
 edition = "2021"
 rust-version = "1.61"
 authors = ["Robin Mueller <muellerr@irs.uni-stuttgart.de>"]
@@ -23,15 +23,15 @@ version = "1"
 optional = true
 
 [dependencies.satrs-core]
-path = "../satrs-core"
-# version = "0.1.0-alpha.1"
+version = "0.1.0-alpha.3"
+# path = "../satrs-core"
 # git = "https://egit.irs.uni-stuttgart.de/rust/sat-rs.git"
 # branch = "main"
 # rev = "35e1f7a983f6535c5571186e361fe101d4306b89"
 
 [dependencies.satrs-mib-codegen]
 path = "codegen"
-version = "0.1.0-alpha.1"
+version = "0.1.0-alpha.2"
 
 [dependencies.serde]
 version = "1"

satrs-mib/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "satrs-mib-codegen"
-version = "0.1.0-alpha.1"
+version = "0.1.0-alpha.2"
 edition = "2021"
 description = "satrs-mib proc macro implementation"
 homepage = "https://egit.irs.uni-stuttgart.de/rust/sat-rs"
@@ -20,8 +20,8 @@ quote = "1"
 proc-macro2 = "1"
 
 [dependencies.satrs-core]
-path = "../../satrs-core"
-# version = "0.1.0-alpha.1"
+version = "0.1.0-alpha.3"
+# path = "../../satrs-core"
 # git = "https://egit.irs.uni-stuttgart.de/rust/sat-rs.git"
 # branch = "main"
 # rev = "35e1f7a983f6535c5571186e361fe101d4306b89"