Merge remote-tracking branch 'origin/main' into sim-mgm-update

satrs/src/pus/mod.rs

@@ -1356,7 +1356,10 @@ pub mod tests {
         ///
         /// The PUS service handler is instantiated with a [EcssTcInStoreConverter].
         pub fn new(id: ComponentId) -> (Self, PusServiceHelperStatic) {
-            let pool_cfg = StaticPoolConfig::new(alloc::vec![(16, 16), (8, 32), (4, 64)], false);
+            let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(
+                alloc::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/src/pus/scheduler.rs

@@ -396,6 +396,9 @@ pub mod alloc_mod {
     #[derive(Debug)]
     pub struct PusScheduler {
         // TODO: Use MonotonicTime from tai-time crate instead of UnixTime and cache leap seconds.
+        // TODO: Introduce optional limit of commands stored in the TC map. If a limit is set,
+        // there will be a check for each insertion whether the map is full, making the memory
+        // usage of the scheduler more deterministic.
         tc_map: BTreeMap<UnixTime, Vec<TcInfo>>,
         pub(crate) current_time: UnixTime,
         time_margin: Duration,
@@ -939,7 +942,10 @@ mod tests {
 
     #[test]
     fn test_reset() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
         let mut buf: [u8; 32] = [0; 32];
@@ -1088,7 +1094,10 @@ mod tests {
     }
     #[test]
     fn test_release_telecommands() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
         let mut buf: [u8; 32] = [0; 32];
@@ -1153,7 +1162,10 @@ mod tests {
 
     #[test]
     fn release_multi_with_same_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
         let mut buf: [u8; 32] = [0; 32];
@@ -1210,7 +1222,10 @@ mod tests {
 
     #[test]
     fn release_with_scheduler_disabled() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
         scheduler.disable();
@@ -1278,7 +1293,10 @@ mod tests {
     fn insert_unwrapped_tc() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            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, &[]);
 
@@ -1325,7 +1343,10 @@ mod tests {
     fn insert_wrapped_tc() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
 
         let mut buf: [u8; 32] = [0; 32];
         let tc = scheduled_tc(UnixTime::new_only_secs(100), &mut buf);
@@ -1374,7 +1395,10 @@ mod tests {
     fn insert_wrong_service() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
 
         let mut buf: [u8; 32] = [0; 32];
         let tc = wrong_tc_service(UnixTime::new_only_secs(100), &mut buf);
@@ -1396,7 +1420,10 @@ mod tests {
     fn insert_wrong_subservice() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
 
         let mut buf: [u8; 32] = [0; 32];
         let tc = wrong_tc_subservice(UnixTime::new_only_secs(100), &mut buf);
@@ -1417,7 +1444,10 @@ mod tests {
     #[test]
     fn insert_wrapped_tc_faulty_app_data() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let tc = invalid_time_tagged_cmd();
         let insert_res = scheduler.insert_wrapped_tc::<cds::CdsTime>(&tc, &mut pool);
         assert!(insert_res.is_err());
@@ -1431,7 +1461,10 @@ mod tests {
     #[test]
     fn insert_doubly_wrapped_time_tagged_cmd() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut buf: [u8; 64] = [0; 64];
         let tc = double_wrapped_time_tagged_tc(UnixTime::new_only_secs(50), &mut buf);
         let insert_res = scheduler.insert_wrapped_tc::<cds::CdsTime>(&tc, &mut pool);
@@ -1465,7 +1498,10 @@ mod tests {
     fn release_time_within_time_margin() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
 
         let mut buf: [u8; 32] = [0; 32];
 
@@ -1489,7 +1525,10 @@ mod tests {
 
     #[test]
     fn test_store_error_propagation_release() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
         let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]);
@@ -1523,7 +1562,10 @@ mod tests {
 
     #[test]
     fn test_store_error_propagation_reset() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
         let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]);
@@ -1546,7 +1588,10 @@ mod tests {
 
     #[test]
     fn test_delete_by_req_id_simple_retrieve_addr() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
         let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]);
@@ -1564,7 +1609,10 @@ mod tests {
 
     #[test]
     fn test_delete_by_req_id_simple_delete_all() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
         let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]);
@@ -1582,7 +1630,10 @@ mod tests {
 
     #[test]
     fn test_delete_by_req_id_complex() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let mut buf: [u8; 32] = [0; 32];
         let tc_info_0 = ping_tc_to_store(&mut pool, &mut buf, 0, &[]);
@@ -1627,7 +1678,10 @@ mod tests {
     fn insert_full_store_test() {
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(1, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(1, 64)],
+            false,
+        ));
 
         let mut buf: [u8; 32] = [0; 32];
         // Store is full after this.
@@ -1663,7 +1717,10 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_all() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1692,7 +1749,10 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_from_stamp() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1724,7 +1784,10 @@ mod tests {
 
     #[test]
     fn test_time_window_retrieval_select_to_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let tc_info_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1756,7 +1819,10 @@ 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)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let _ = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let tc_info_1 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1794,7 +1860,10 @@ mod tests {
 
     #[test]
     fn test_deletion_all() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1820,7 +1889,10 @@ mod tests {
 
     #[test]
     fn test_deletion_from_start_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1842,7 +1914,10 @@ mod tests {
 
     #[test]
     fn test_deletion_to_end_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let cmd_1_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1865,7 +1940,10 @@ mod tests {
 
     #[test]
     fn test_deletion_from_start_time_to_end_time() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
         let cmd_out_of_range_0 = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 50);
         let cmd_0_to_delete = insert_command_with_release_time(&mut pool, &mut scheduler, 0, 100);
@@ -1897,7 +1975,10 @@ mod tests {
 
     #[test]
     fn test_release_without_deletion() {
-        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(10, 32), (5, 64)], false));
+        let mut pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(10, 32), (5, 64)],
+            false,
+        ));
         let mut scheduler = PusScheduler::new(UnixTime::new_only_secs(0), Duration::from_secs(5));
 
         let mut buf: [u8; 32] = [0; 32];

satrs/src/pus/scheduler_srv.rs

@@ -286,7 +286,10 @@ 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)], false);
+            let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(
+                alloc::vec![(16, 16), (8, 32), (4, 64)],
+                false,
+            );
             let sched_tc_pool = StaticMemoryPool::new(pool_cfg.clone());
             let (common, srv_handler) = PusServiceHandlerWithSharedStoreCommon::new(0);
             Self {

satrs/src/pus/verification.rs

@@ -31,7 +31,9 @@
 //! const TEST_APID: u16 = 0x02;
 //! const TEST_COMPONENT_ID: UniqueApidTargetId = UniqueApidTargetId::new(TEST_APID, 0x05);
 //!
-//! let pool_cfg = StaticPoolConfig::new(vec![(10, 32), (10, 64), (10, 128), (10, 1024)], false);
+//! let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(
+//!     vec![(10, 32), (10, 64), (10, 128), (10, 1024)], false
+//! );
 //! let tm_pool = StaticMemoryPool::new(pool_cfg.clone());
 //! let shared_tm_pool = SharedStaticMemoryPool::new(RwLock::new(tm_pool));
 //! let (verif_tx, verif_rx) = mpsc::sync_channel(10);
@@ -1248,7 +1250,7 @@ pub fn handle_completion_failure_with_generic_params<TcState: WasAtLeastAccepted
     Ok(error_params_propagated)
 }
 
-/// This function is similar to [handle_completion_failure_with_error_as_params] but handles the
+/// This function is similar to [handle_completion_failure_with_generic_params] but handles the
 /// step failure case.
 pub fn handle_step_failure_with_generic_params(
     tm_sender: &(impl EcssTmSender + ?Sized),
@@ -2069,7 +2071,10 @@ pub mod tests {
 
     #[test]
     fn test_mpsc_verif_send() {
-        let pool = StaticMemoryPool::new(StaticPoolConfig::new(vec![(8, 8)], false));
+        let pool = StaticMemoryPool::new(StaticPoolConfig::new_from_subpool_cfg_tuples(
+            vec![(8, 8)],
+            false,
+        ));
         let shared_tm_store =
             SharedPacketPool::new(&SharedStaticMemoryPool::new(RwLock::new(pool)));
         let (tx, _) = mpsc::sync_channel(10);

satrs/src/tmtc/mod.rs

@@ -486,7 +486,9 @@ pub(crate) mod tests {
 
     use std::sync::RwLock;
 
-    use crate::pool::{PoolProviderWithGuards, StaticMemoryPool, StaticPoolConfig};
+    use crate::pool::{
+        PoolProviderWithGuards, SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig,
+    };
 
     use super::*;
     use std::sync::mpsc;
@@ -554,7 +556,7 @@ pub(crate) mod tests {
     #[test]
     fn test_basic_shared_store_sender_unbounded_sender() {
         let (tc_tx, tc_rx) = mpsc::channel();
-        let pool_cfg = StaticPoolConfig::new(vec![(2, 8)], true);
+        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(vec![(2, 8)], true);
         let shared_pool = SharedPacketPool::new(&SharedStaticMemoryPool::new(RwLock::new(
             StaticMemoryPool::new(pool_cfg),
         )));
@@ -571,7 +573,7 @@ pub(crate) mod tests {
     #[test]
     fn test_basic_shared_store_sender() {
         let (tc_tx, tc_rx) = mpsc::sync_channel(10);
-        let pool_cfg = StaticPoolConfig::new(vec![(2, 8)], true);
+        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(vec![(2, 8)], true);
         let shared_pool = SharedPacketPool::new(&SharedStaticMemoryPool::new(RwLock::new(
             StaticMemoryPool::new(pool_cfg),
         )));
@@ -588,7 +590,7 @@ pub(crate) mod tests {
     #[test]
     fn test_basic_shared_store_sender_rx_dropped() {
         let (tc_tx, tc_rx) = mpsc::sync_channel(10);
-        let pool_cfg = StaticPoolConfig::new(vec![(2, 8)], true);
+        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(vec![(2, 8)], true);
         let shared_pool = SharedPacketPool::new(&SharedStaticMemoryPool::new(RwLock::new(
             StaticMemoryPool::new(pool_cfg),
         )));
@@ -606,7 +608,7 @@ pub(crate) mod tests {
     #[test]
     fn test_basic_shared_store_sender_queue_full() {
         let (tc_tx, tc_rx) = mpsc::sync_channel(1);
-        let pool_cfg = StaticPoolConfig::new(vec![(2, 8)], true);
+        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(vec![(2, 8)], true);
         let shared_pool = SharedPacketPool::new(&SharedStaticMemoryPool::new(RwLock::new(
             StaticMemoryPool::new(pool_cfg),
         )));
@@ -629,7 +631,7 @@ pub(crate) mod tests {
     #[test]
     fn test_basic_shared_store_store_error() {
         let (tc_tx, tc_rx) = mpsc::sync_channel(1);
-        let pool_cfg = StaticPoolConfig::new(vec![(1, 8)], true);
+        let pool_cfg = StaticPoolConfig::new_from_subpool_cfg_tuples(vec![(1, 8)], true);
         let shared_pool = SharedPacketPool::new(&SharedStaticMemoryPool::new(RwLock::new(
             StaticMemoryPool::new(pool_cfg),
         )));