Push the KV buffer into DataModelState

Author: ivmarkov

bloat-check/src/bin/bloat-check.rs

@@ -41,7 +41,9 @@
 #![recursion_limit = "256"]
 
 use core::future::Future;
-use core::mem::{size_of_val, MaybeUninit};
+use core::mem::size_of_val;
+#[cfg(target_os = "none")]
+use core::mem::MaybeUninit;
 
 // Logging - `defmt` for embedded targets, `log` for others
 #[cfg(target_os = "none")]
@@ -69,20 +71,18 @@ use rs_matter::dm::clusters::wifi_diag::{
 use rs_matter::dm::devices::test::{DAC_PRIVKEY, TEST_DEV_ATT, TEST_DEV_COMM, TEST_DEV_DET};
 use rs_matter::dm::devices::DEV_TYPE_ON_OFF_LIGHT;
 use rs_matter::dm::endpoints::WifiSysHandler;
-use rs_matter::dm::events::DEFAULT_MAX_EVENTS_BUF_SIZE;
 use rs_matter::dm::networks::wireless::{
     NetCtlState, NetCtlStateMutex, NetCtlWithStatusImpl, WifiNetworks,
 };
 use rs_matter::dm::networks::NetChangeNotif;
-use rs_matter::dm::subscriptions::DEFAULT_MAX_SUBSCRIPTIONS;
 use rs_matter::dm::{endpoints, IMBuffer};
 use rs_matter::dm::{
     Async, DataModel, Dataver, Endpoint, EpClMatcher, Node, WirelessDataModelState,
 };
 use rs_matter::error::Error;
 use rs_matter::pairing::qr::QrTextType;
 use rs_matter::pairing::DiscoveryCapabilities;
-use rs_matter::persist::{DummyKvBlobStore, SharedKvBlobStore};
+use rs_matter::persist::{DummyKvBlobStore, SharedKvBlobStore, DEFAULT_KV_BUF_SIZE};
 use rs_matter::respond::DefaultResponder;
 use rs_matter::sc::pase::MAX_COMM_WINDOW_TIMEOUT_SECS;
 use rs_matter::tlv::Nullable;
@@ -162,8 +162,6 @@ struct MatterStack<'a> {
     state: WirelessDataModelState<WifiNetworks<3>>,
     net_ctl_state: NetCtlStateMutex,
     btp: Btp,
-    // We don't run a persistence task, but emulate its typical memory consumnption
-    psm_buffer: MaybeUninit<[u8; 4096]>,
 }
 
 impl<'a> MatterStack<'a> {
@@ -180,7 +178,6 @@ impl<'a> MatterStack<'a> {
             state <- WirelessDataModelState::init(WifiNetworks::init()),
             net_ctl_state <- NetCtlState::init_with_mutex(),
             btp <- Btp::init(),
-            psm_buffer: MaybeUninit::zeroed(),
         })
     }
 }
@@ -198,24 +195,20 @@ type AppDmHandler<'a> = handler_chain_type!(
 type AppCrypto = RustCrypto<'static, WeakTestOnlyRand>;
 type AppDataModel<'a> = DataModel<
     'a,
-    DEFAULT_MAX_SUBSCRIPTIONS,
-    DEFAULT_MAX_EVENTS_BUF_SIZE,
     &'a AppCrypto,
     PooledBuffers<10, IMBuffer>,
     (Node<'a>, &'a AppDmHandler<'a>),
-    SharedKvBlobStore<DummyKvBlobStore, &'static mut [u8]>,
+    DummyKvBlobStore,
     WifiNetworks<3>,
     &'a AppNetCtl<'a>,
 >;
 type AppResponder<'d, 'a> = DefaultResponder<
     'd,
     'a,
-    DEFAULT_MAX_SUBSCRIPTIONS,
-    DEFAULT_MAX_EVENTS_BUF_SIZE,
     &'a AppCrypto,
     PooledBuffers<10, IMBuffer>,
     (Node<'a>, &'a AppDmHandler<'a>),
-    SharedKvBlobStore<DummyKvBlobStore, &'static mut [u8]>,
+    DummyKvBlobStore,
     WifiNetworks<3>,
     &'a AppNetCtl<'a>,
 >;
@@ -289,11 +282,10 @@ fn main() -> ! {
         &mut stack_total,
     );
     report_size("BTP", size_of_val(&stack.btp), &mut stack_total);
-    report_size(
-        "Persister buffer",
-        size_of_val(&stack.psm_buffer),
-        &mut stack_total,
-    );
+    // The KV/persister scratch buffer now lives inside `DataModelState` (behind a
+    // blocking mutex) rather than in the `SharedKvBlobStore`. It is not visible
+    // through the per-component accessors above, so account for it explicitly.
+    report_size("KV scratch buffer", DEFAULT_KV_BUF_SIZE, &mut stack_total);
 
     report_subtotal_size("TOTAL MATTER STACK ", stack_total);
 
@@ -322,8 +314,9 @@ fn main() -> ! {
 
     let mut rand = unwrap!(crypto.weak_rand());
 
-    let kv_buf = unsafe { stack.psm_buffer.assume_init_mut() }.as_mut_slice();
-    let kv = SharedKvBlobStore::new(DummyKvBlobStore, kv_buf);
+    // The KV scratch buffer now lives inside `DataModelState` (see the "KV scratch
+    // buffer" line in the memory report); the store itself is buffer-less.
+    let kv = SharedKvBlobStore::new(DummyKvBlobStore);
 
     // A Wireless handler with a sample app cluster (on-off)
     let handler = mk_static!(

examples/src/bin/bridge.rs

@@ -69,17 +69,20 @@ fn main() -> Result<(), Error> {
     let mut matter = Matter::new(&TEST_DEV_DET, TEST_DEV_COMM, &TEST_DEV_ATT, MATTER_PORT);
 
     // Persistence
-    let mut kv_buf = [0; 4096];
     let mut kv = DirKvBlobStore::new_default();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, &mut kv_buf))?;
 
     // Create the transport buffers
     let buffers = PooledBuffers::<10, _>::new(0);
 
-    // Create the data model state (subscriptions, events, network store) and load
-    // the persisted event counter.
+    // Create the data model state (subscriptions, events, network store). It owns
+    // the KV scratch buffer, which the startup loads below reuse rather than
+    // allocating a separate one.
     let mut state: EthDataModelState = EthDataModelState::new(EthNetwork::new_default());
-    futures_lite::future::block_on(state.load_persist(&mut kv, &mut kv_buf))?;
+
+    // Re-hydrate the `Matter` instance and the data model state (event-number
+    // epoch) using the state's own scratch buffer.
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
+    futures_lite::future::block_on(state.load_persist(&mut kv))?;
 
     // Create the crypto instance
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
@@ -104,7 +107,7 @@ fn main() -> Result<(), Error> {
         &crypto,
         &buffers,
         dm_handler(rand, &on_off_handler_ep2, &on_off_handler_ep3),
-        SharedKvBlobStore::new(kv, kv_buf.as_mut_slice()),
+        SharedKvBlobStore::new(kv),
         &state,
     );
 

examples/src/bin/camera_tests.rs

@@ -371,7 +371,6 @@ type WebRtc = WebRtcProvHandler<StubWebRtcHooks, N_SESSIONS, SDP_LEN, OUT_LEN, C
 
 static MATTER: StaticCell<Matter> = StaticCell::new();
 static BUFFERS: StaticCell<PooledBuffers<10, rs_matter::dm::IMBuffer>> = StaticCell::new();
-static KV_BUF: StaticCell<[u8; 4096]> = StaticCell::new();
 static WEBRTC: StaticCell<WebRtc> = StaticCell::new();
 static CAM_AV: StaticCell<CamAv> = StaticCell::new();
 static CAM_AV_SETTINGS: StaticCell<
@@ -405,16 +404,19 @@ fn main() -> Result<(), Error> {
         args::port_override(),
     ));
 
-    let kv_buf = KV_BUF.uninit().init_zeroed().as_mut_slice();
     let mut kv = args::file_kv_store();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, kv_buf))?;
 
     let buffers = BUFFERS.uninit().init_with(PooledBuffers::init(0));
 
-    // Create the data model state (subscriptions, events, network store) and load
-    // the persisted event counter.
+    // Create the data model state (subscriptions, events, network store). It owns
+    // the KV scratch buffer, which the startup loads below reuse rather than
+    // allocating a separate one.
     let mut state: EthDataModelState = EthDataModelState::new(EthNetwork::new_default());
-    futures_lite::future::block_on(state.load_persist(&mut kv, kv_buf))?;
+
+    // Re-hydrate the `Matter` instance and the data model state (event-number
+    // epoch) using the state's own scratch buffer.
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
+    futures_lite::future::block_on(state.load_persist(&mut kv))?;
 
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
     let mut rand = crypto.rand()?;
@@ -572,7 +574,7 @@ fn main() -> Result<(), Error> {
             push_av,
             chime,
         ),
-        SharedKvBlobStore::new(kv, kv_buf),
+        SharedKvBlobStore::new(kv),
         &state,
     );
 

examples/src/bin/dimmable_light.rs

@@ -76,17 +76,20 @@ fn main() -> Result<(), Error> {
     let mut matter = Matter::new(&TEST_DEV_DET, TEST_DEV_COMM, &TEST_DEV_ATT, MATTER_PORT);
 
     // Persistence
-    let mut kv_buf = [0u8; 4096];
     let mut kv = rs_matter::persist::DirKvBlobStore::new_default();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, &mut kv_buf))?;
 
     // Create the transport buffers
     let buffers = PooledBuffers::<10, IMBuffer>::new(0);
 
-    // Create the data model state (subscriptions, events, network store) and load
-    // the persisted event counter.
+    // Create the data model state (subscriptions, events, network store). It owns
+    // the KV scratch buffer, which the startup loads below reuse rather than
+    // allocating a separate one.
     let mut state: EthDataModelState = EthDataModelState::new(EthNetwork::new_default());
-    futures_lite::future::block_on(state.load_persist(&mut kv, &mut kv_buf))?;
+
+    // Re-hydrate the `Matter` instance and the data model state (event-number
+    // epoch) using the state's own scratch buffer.
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
+    futures_lite::future::block_on(state.load_persist(&mut kv))?;
 
     // Create the crypto instance
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
@@ -119,7 +122,7 @@ fn main() -> Result<(), Error> {
         &crypto,
         &buffers,
         dm_handler(rand, &on_off_handler, &level_control_handler),
-        SharedKvBlobStore::new(kv, kv_buf),
+        SharedKvBlobStore::new(kv),
         &state,
     );
 

examples/src/bin/light_tests.rs

@@ -79,7 +79,6 @@ mod args;
 static MATTER: StaticCell<Matter> = StaticCell::new();
 static BUFFERS: StaticCell<PooledBuffers<10, IMBuffer>> = StaticCell::new();
 static STATE: StaticCell<EthDataModelState> = StaticCell::new();
-static KV_BUF: StaticCell<[u8; 4096]> = StaticCell::new();
 
 fn main() -> Result<(), Error> {
     let thread = std::thread::Builder::new()
@@ -106,16 +105,19 @@ fn run() -> Result<(), Error> {
         args::port_override(),
     ));
 
-    let kv_buf = KV_BUF.uninit().init_zeroed().as_mut_slice();
     let mut kv = args::file_kv_store();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, kv_buf))?;
 
     let buffers = BUFFERS.uninit().init_with(PooledBuffers::init(0));
 
-    // Create the data model state (subscriptions, events, network store) and load
-    // the persisted event counter.
+    // Create the data model state (subscriptions, events, network store). It owns
+    // the KV scratch buffer, which the startup loads below reuse rather than
+    // allocating a separate one.
     let state = STATE.init(EthDataModelState::new(EthNetwork::new_default()));
-    futures_lite::future::block_on(state.load_persist(&mut kv, kv_buf))?;
+
+    // Re-hydrate the `Matter` instance and the data model state (event-number
+    // epoch) using the state's own scratch buffer.
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
+    futures_lite::future::block_on(state.load_persist(&mut kv))?;
 
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
     let mut rand = crypto.rand()?;
@@ -160,7 +162,7 @@ fn run() -> Result<(), Error> {
             &level_control_handler,
             &color_control_handler,
         ),
-        SharedKvBlobStore::new(kv, kv_buf),
+        SharedKvBlobStore::new(kv),
         state,
     );
 

examples/src/bin/media_player.rs

@@ -85,17 +85,20 @@ fn main() -> Result<(), Error> {
     let mut matter = Matter::new(&TEST_DEV_DET, TEST_DEV_COMM, &TEST_DEV_ATT, MATTER_PORT);
 
     // Persistence
-    let mut kv_buf = [0; 4096];
     let mut kv = DirKvBlobStore::new_default();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, &mut kv_buf))?;
 
     // Create the transport buffers
     let buffers = PooledBuffers::<10, _>::new(0);
 
-    // Create the data model state (subscriptions, events, network store) and load
-    // the persisted event counter.
+    // Create the data model state (subscriptions, events, network store). It owns
+    // the KV scratch buffer, which the startup loads below reuse rather than
+    // allocating a separate one.
     let mut state: EthDataModelState = EthDataModelState::new(EthNetwork::new_default());
-    futures_lite::future::block_on(state.load_persist(&mut kv, &mut kv_buf))?;
+
+    // Re-hydrate the `Matter` instance and the data model state (event-number
+    // epoch) using the state's own scratch buffer.
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
+    futures_lite::future::block_on(state.load_persist(&mut kv))?;
 
     // Create the crypto instance
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
@@ -115,7 +118,7 @@ fn main() -> Result<(), Error> {
         &crypto,
         &buffers,
         dm_handler(rand, &on_off_handler),
-        SharedKvBlobStore::new(kv, kv_buf.as_mut_slice()),
+        SharedKvBlobStore::new(kv),
         &state,
     );
 

examples/src/bin/onoff_light.rs

@@ -61,15 +61,19 @@ fn main() -> Result<(), Error> {
     let mut matter = Matter::new(&TEST_DEV_DET, TEST_DEV_COMM, &TEST_DEV_ATT, MATTER_PORT);
 
     // Persistence
-    let mut kv_buf = [0u8; 4096];
     let mut kv = DirKvBlobStore::new_default();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, &mut kv_buf))?;
 
     // Create the transport buffers
     let buffers = PooledBuffers::<10, IMBuffer>::new(0);
 
-    // Create the data model state (subscriptions table, events queue, network store)
-    let state: EthDataModelState = EthDataModelState::new(EthNetwork::new_default());
+    // Create the data model state (subscriptions table, events queue, network
+    // store). It owns the KV scratch buffer, which we reuse for the startup load
+    // below rather than allocating a separate one.
+    let mut state: EthDataModelState = EthDataModelState::new(EthNetwork::new_default());
+
+    // Re-hydrate the `Matter` instance (fabrics, ACLs, basic info) using the
+    // state's own scratch buffer.
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
 
     // Create the crypto instance
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
@@ -89,7 +93,7 @@ fn main() -> Result<(), Error> {
         &crypto,
         &buffers,
         dm_handler(rand, &on_off_handler),
-        SharedKvBlobStore::new(kv, kv_buf),
+        SharedKvBlobStore::new(kv),
         &state,
     );
 

examples/src/bin/onoff_light_bt.rs

@@ -126,23 +126,22 @@ fn run<N: NetCtl + WifiDiag + NetChangeNotif>(
     // Create the Matter object
     let mut matter = Matter::new(&TEST_DEV_DET, TEST_DEV_COMM, &TEST_DEV_ATT, MATTER_PORT);
 
-    // A storage for the Wifi networks, re-hydrated from persistence.
-    let mut networks = WifiNetworks::<3>::new();
-
     // Persistence
-    let mut kv_buf = [0; 4096];
     let mut kv = DirKvBlobStore::new_default();
-    futures_lite::future::block_on(matter.load_persist(&mut kv, &mut kv_buf))?;
-    futures_lite::future::block_on(networks.load_persist(&mut kv, &mut kv_buf))?;
 
     // Create the transport buffers
     let buffers = PooledBuffers::<10, _>::new(0);
 
-    // Create the data model state (subscriptions, events, the Wifi network store)
-    // and load the persisted event counter. The (raw) network store was loaded
-    // above, before being moved into the state.
-    let mut state: WirelessDataModelState<WifiNetworks<3>> = WirelessDataModelState::new(networks);
-    futures_lite::future::block_on(state.load_persist(&mut kv, &mut kv_buf))?;
+    // Create the data model state (subscriptions, events, the Wifi network store).
+    // It owns the KV scratch buffer, so the one-time startup loads below reuse it
+    // (`state.kv_buf_mut()`) rather than allocating a separate buffer.
+    let mut state: WirelessDataModelState<WifiNetworks<3>> =
+        WirelessDataModelState::new(WifiNetworks::new());
+
+    // Re-hydrate persisted state: the `Matter` instance (fabrics, ACLs, basic
+    // info) and the data model state itself (event-number epoch + Wifi networks).
+    futures_lite::future::block_on(matter.load_persist(&mut kv, state.kv_buf_mut()))?;
+    futures_lite::future::block_on(state.load_persist(&mut kv))?;
 
     // Create the crypto instance
     let crypto = default_crypto(rand::thread_rng(), DAC_PRIVKEY);
@@ -169,7 +168,7 @@ fn run<N: NetCtl + WifiDiag + NetChangeNotif>(
         &crypto,
         &buffers,
         dm_handler(rand, &on_off_handler, &net_ctl, &net_ctl),
-        SharedKvBlobStore::new(kv, kv_buf.as_mut_slice()),
+        SharedKvBlobStore::new(kv),
         &net_ctl,
         &state,
     );