From c0692a35238094a9404ad15cee6ae212506b8270 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Mon, 12 Feb 2024 11:35:10 +0100 Subject: [PATCH] Added static pool spillover feature - Allows to utilize the full pool even if some subpools are full. --- satrs-core/src/pool.rs | 106 ++++++++++++++++++++++++--- satrs-core/src/pus/mod.rs | 2 +- satrs-core/src/pus/scheduler.rs | 52 ++++++------- satrs-core/src/pus/scheduler_srv.rs | 2 +- satrs-core/src/pus/verification.rs | 8 +- satrs-core/tests/pools.rs | 2 +- satrs-core/tests/pus_verification.rs | 3 +- satrs-example/src/config.rs | 57 ++++++++------ 8 files changed, 164 insertions(+), 68 deletions(-) diff --git a/satrs-core/src/pool.rs b/satrs-core/src/pool.rs index 26820c5..fb59065 100644 --- a/satrs-core/src/pool.rs +++ b/satrs-core/src/pool.rs @@ -6,7 +6,7 @@ //! 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 +369,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, but it might also lead to frequently used + /// subpools which were not dimensioned properly chocking larger 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 +475,17 @@ mod alloc_mod { } fn reserve(&mut self, data_len: usize) -> Result { - 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 +657,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 +965,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"); + } + } } diff --git a/satrs-core/src/pus/mod.rs b/satrs-core/src/pus/mod.rs index 5a21d95..9001f8b 100644 --- a/satrs-core/src/pus/mod.rs +++ b/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) { - 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)); diff --git a/satrs-core/src/pus/scheduler.rs b/satrs-core/src/pus/scheduler.rs index b05dca8..a2ce7fe 100644 --- a/satrs-core/src/pus/scheduler.rs +++ b/satrs-core/src/pus/scheduler.rs @@ -945,7 +945,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 +1097,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 +1163,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 +1221,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 +1291,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 +1339,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 +1389,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 +1412,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 +1434,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::(&tc, &mut pool); assert!(insert_res.is_err()); @@ -1449,7 +1449,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::(&tc, &mut pool); @@ -1485,7 +1485,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 +1509,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 +1544,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 +1568,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 +1587,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 +1606,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 +1653,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 +1692,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 +1723,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 +1754,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 +1785,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 +1820,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 +1847,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 +1868,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 +1890,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 +1919,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)); diff --git a/satrs-core/src/pus/scheduler_srv.rs b/satrs-core/src/pus/scheduler_srv.rs index 3e9ab32..18f1b58 100644 --- a/satrs-core/src/pus/scheduler_srv.rs +++ b/satrs-core/src/pus/scheduler_srv.rs @@ -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 { diff --git a/satrs-core/src/pus/verification.rs b/satrs-core/src/pus/verification.rs index 36514f1..de3ce97 100644 --- a/satrs-core/src/pus/verification.rs +++ b/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(); diff --git a/satrs-core/tests/pools.rs b/satrs-core/tests/pools.rs index a091203..94272c0 100644 --- a/satrs-core/tests/pools.rs +++ b/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, Receiver) = mpsc::channel(); diff --git a/satrs-core/tests/pus_verification.rs b/satrs-core/tests/pus_verification.rs index f299272..84a105c 100644 --- a/satrs-core/tests/pus_verification.rs +++ b/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(); diff --git a/satrs-example/src/config.rs b/satrs-example/src/config.rs index a2fabd8..bf47691 100644 --- a/satrs-example/src/config.rs +++ b/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, + )) } }