Cut the size of a boxed Context to 930 bytes + 6 allocs and a boxed

ThreadSafeContext to 1097 bytes + 6 allocs, and profiling actual usage
and reducing initial allocation/capacity for data structures

Author: lilith

imageflow_abi/src/lib.rs

@@ -8,7 +8,7 @@
 //! As of ABI 3.1, calls are thread-safe.
 //!
 //! Don't worry about the performance of creating/destroying contexts.
-//! A context weighs less than 2kb: (384 + 1400) as of 2017-8-29.
+//! A context weighs only 1100 bytes (6 allocations) as of Oct 2025.
 //!
 //! # Thread Safety
 //!
@@ -949,7 +949,7 @@ pub unsafe extern "C" fn imageflow_context_send_json(
     json_buffer: *const u8,
     json_buffer_size: libc::size_t,
 ) -> *const JsonResponse {
-    let mut c = context!(context);
+    let c = context!(context);
     if c.outward_error().has_error() {
         let json_error = c.outward_error().get_json_response_for_error();
         if let Some(json_error) = json_error {

imageflow_core/src/context.rs

@@ -21,6 +21,7 @@ use imageflow_types::ImageInfo;
 use itertools::Itertools;
 
 /// Something of a god object (which is necessary for a reasonable FFI interface).
+/// 1025 bytes including 5 heap allocations as of Oct 2025. If on the stack, 312 bytes are taken up
 pub struct Context {
     pub debug_job_id: i32,
     pub next_stable_node_id: i32,
@@ -88,7 +89,7 @@ impl ThreadSafeContext {
         }))
     }
     pub fn create_cant_panic() -> Result<Box<ThreadSafeContext>> {
-        std::panic::catch_unwind(|| ThreadSafeContext::create_can_panic())
+        std::panic::catch_unwind(ThreadSafeContext::create_can_panic)
             .unwrap_or_else(|_| Err(err_oom!())) //err_oom because it doesn't allocate anything.
     }
 
@@ -132,6 +133,25 @@ impl ThreadSafeContext {
         }
         true
     }
+
+    /// Calculates the total size and count of all heap allocations in a new ThreadSafeContext
+    /// Returns (total_bytes, num_allocations)
+    ///
+    /// This includes:
+    /// - Initial heap allocations for collections (codecs, io_id_list, bitmaps, allocations)
+    /// - Arc allocations for shared state
+    ///
+    /// Note: RwLock and Mutex store their contents inline, not on the heap
+    pub(crate) fn calculate_heap_allocations() -> (usize, usize) {
+        // Get Context's heap allocations (this is shared via RwLock but stored inline in ThreadSafeContext)
+        let (context_bytes, context_allocs) = Context::calculate_heap_allocations();
+
+        (
+            context_bytes + std::mem::size_of::<ThreadSafeContext>()
+                - std::mem::size_of::<Context>(),
+            context_allocs,
+        )
+    }
     /// mem_calloc should not panic
     pub unsafe fn mem_calloc(
         &self,
@@ -206,11 +226,13 @@ impl Context {
             next_stable_node_id: 0,
             max_calc_flatten_execute_passes: 40,
             graph_recording: s::Build001GraphRecording::off(),
-            codecs: AddRemoveSet::with_capacity(4),
-            io_id_list: RefCell::new(Vec::with_capacity(2)),
+            codecs: AddRemoveSet::with_capacity(Self::default_codecs_capacity()),
+            io_id_list: RefCell::new(Vec::with_capacity(Self::default_codecs_capacity())),
             cancellation_token: CancellationToken::new(),
             enabled_codecs: EnabledCodecs::default(),
-            bitmaps: RefCell::new(crate::graphics::bitmaps::BitmapsContainer::with_capacity(16)),
+            bitmaps: RefCell::new(
+                crate::graphics::bitmaps::BitmapsContainer::with_default_capacity(),
+            ),
             security: imageflow_types::ExecutionSecurity {
                 max_decode_size: None,
                 max_frame_size: Some(imageflow_types::FrameSizeLimit {
@@ -223,18 +245,23 @@ impl Context {
             allocations: RefCell::new(AllocationContainer::new()),
         }))
     }
+    fn default_codecs_capacity() -> usize {
+        2
+    }
     pub(crate) fn create_can_panic_unboxed() -> Result<Context> {
         Ok(Context {
             debug_job_id: unsafe { JOB_ID },
             next_graph_version: 0,
             next_stable_node_id: 0,
             max_calc_flatten_execute_passes: 40,
             graph_recording: s::Build001GraphRecording::off(),
-            codecs: AddRemoveSet::with_capacity(4),
-            io_id_list: RefCell::new(Vec::with_capacity(2)),
+            codecs: AddRemoveSet::with_capacity(Self::default_codecs_capacity()),
+            io_id_list: RefCell::new(Vec::with_capacity(Self::default_codecs_capacity())),
             cancellation_token: CancellationToken::new(),
             enabled_codecs: EnabledCodecs::default(),
-            bitmaps: RefCell::new(crate::graphics::bitmaps::BitmapsContainer::with_capacity(16)),
+            bitmaps: RefCell::new(
+                crate::graphics::bitmaps::BitmapsContainer::with_default_capacity(),
+            ),
             security: imageflow_types::ExecutionSecurity {
                 max_decode_size: None,
                 max_frame_size: Some(imageflow_types::FrameSizeLimit {
@@ -256,11 +283,13 @@ impl Context {
             next_stable_node_id: 0,
             max_calc_flatten_execute_passes: 40,
             graph_recording: s::Build001GraphRecording::off(),
-            codecs: AddRemoveSet::with_capacity(4),
-            io_id_list: RefCell::new(Vec::with_capacity(2)),
+            codecs: AddRemoveSet::with_capacity(Self::default_codecs_capacity()),
+            io_id_list: RefCell::new(Vec::with_capacity(Self::default_codecs_capacity())),
             cancellation_token,
             enabled_codecs: EnabledCodecs::default(),
-            bitmaps: RefCell::new(crate::graphics::bitmaps::BitmapsContainer::with_capacity(16)),
+            bitmaps: RefCell::new(
+                crate::graphics::bitmaps::BitmapsContainer::with_default_capacity(),
+            ),
             security: imageflow_types::ExecutionSecurity {
                 max_decode_size: None,
                 max_frame_size: Some(imageflow_types::FrameSizeLimit {
@@ -592,6 +621,55 @@ impl Context {
             .to_owned(),
         })
     }
+
+    /// Calculates the total size and count of all stack andheap allocations in a new Context
+    /// Returns (total_bytes, num_allocations)
+    ///
+    /// This includes:
+    /// - Initial capacity allocations for collections (codecs, io_id_list, bitmaps, allocations)
+    /// - Arc allocation for shared state (cancellation_token)
+    ///
+    /// Note: RefCell stores its contents inline, not on the heap
+    pub(crate) fn calculate_heap_allocations() -> (usize, usize) {
+        let mut total_bytes = 0;
+        let mut num_allocations = 0;
+
+        total_bytes += std::mem::size_of::<Context>();
+        // AddRemoveSet<CodecInstanceContainer> with capacity 4
+        // This is typically backed by a Vec, so 1 allocation for the buffer
+        if std::mem::size_of::<CodecInstanceContainer>() * Self::default_codecs_capacity() > 0 {
+            total_bytes +=
+                std::mem::size_of::<CodecInstanceContainer>() * Self::default_codecs_capacity();
+            num_allocations += 1;
+        }
+
+        // Vec<i32> with capacity 2 (inside RefCell, but RefCell is inline)
+        if std::mem::size_of::<i32>() * Self::default_codecs_capacity() > 0 {
+            total_bytes += std::mem::size_of::<i32>() * Self::default_codecs_capacity();
+            num_allocations += 1;
+        }
+
+        // DenseSlotMap in BitmapsContainer with capacity 16
+        // DenseSlotMap typically uses 2 Vec allocations (one for slots, one for keys)
+        let slot_size = std::mem::size_of::<RefCell<crate::graphics::bitmaps::Bitmap>>();
+        let key_size = std::mem::size_of::<crate::graphics::bitmaps::BitmapKey>();
+        if slot_size * crate::graphics::bitmaps::BitmapsContainer::default_capacity() > 0 {
+            total_bytes +=
+                slot_size * crate::graphics::bitmaps::BitmapsContainer::default_capacity();
+            num_allocations += 1;
+        }
+        if key_size * crate::graphics::bitmaps::BitmapsContainer::default_capacity() > 0 {
+            total_bytes +=
+                key_size * crate::graphics::bitmaps::BitmapsContainer::default_capacity();
+            num_allocations += 1;
+        }
+
+        // Arc<AtomicBool> for cancellation_token - 1 heap allocation
+        total_bytes += std::mem::size_of::<AtomicBool>();
+        num_allocations += 1;
+
+        (total_bytes, num_allocations)
+    }
 }
 
 #[cfg(test)]
@@ -615,6 +693,43 @@ impl Drop for Context {
 
 #[test]
 fn test_context_size() {
-    println!("std::mem::sizeof(Context) = {}", std::mem::size_of::<Context>());
-    assert!(std::mem::size_of::<Context>() < 500);
+    eprintln!("std::mem::sizeof(Context) = {}", std::mem::size_of::<Context>());
+    assert!(std::mem::size_of::<Context>() < 320);
+}
+
+#[test]
+fn test_thread_safe_context_size() {
+    println!("std::mem::sizeof(ThreadSafeContext) = {}", std::mem::size_of::<ThreadSafeContext>());
+    eprintln!("std::mem::sizeof(ThreadSafeContext) = {}", std::mem::size_of::<ThreadSafeContext>());
+    assert!(std::mem::size_of::<ThreadSafeContext>() <= 488);
+}
+
+#[test]
+fn test_calculate_context_heap_size() {
+    let (context_bytes, context_allocs) = Context::calculate_heap_allocations();
+    let (thread_safe_bytes, thread_safe_allocs) = ThreadSafeContext::calculate_heap_allocations();
+
+    eprintln!(
+        "Context::calculate_heap_allocations() = ({} bytes, {} allocations)",
+        context_bytes, context_allocs
+    );
+    eprintln!(
+        "ThreadSafeContext::calculate_heap_allocations() = ({} bytes, {} allocations)",
+        thread_safe_bytes, thread_safe_allocs
+    );
+
+    // ThreadSafeContext and Context share the same heap allocations (Context is inside RwLock)
+    assert!(thread_safe_bytes > context_bytes);
+    assert!(thread_safe_allocs >= context_allocs);
+
+    // Sanity check: should have some allocations
+    assert!(context_allocs > 0);
+    assert!(context_bytes > 0);
+
+    // Fail if this grows so we can notice it
+    assert!(context_allocs <= 6);
+    assert!(context_bytes <= 930);
+
+    assert!(context_allocs <= 6);
+    assert!(thread_safe_bytes <= 1097);
 }

imageflow_core/src/graphics/bitmaps.rs

@@ -22,6 +22,12 @@ pub struct BitmapsContainer {
     map: ::slotmap::DenseSlotMap<BitmapKey, RefCell<Bitmap>>,
 }
 
+// impl Drop for BitmapsContainer {
+//     fn drop(&mut self) {
+//         eprintln!("Dropping BitmapsContainer with {} bitmaps", self.map.len());
+//     }
+// }
+
 impl BitmapsContainer {
     pub fn with_capacity(capacity: usize) -> BitmapsContainer {
         BitmapsContainer {
@@ -30,6 +36,12 @@ impl BitmapsContainer {
             ),
         }
     }
+    pub fn with_default_capacity() -> BitmapsContainer {
+        Self::with_capacity(Self::default_capacity())
+    }
+    pub fn default_capacity() -> usize {
+        3
+    }
     pub fn get(&self, key: BitmapKey) -> Option<&RefCell<Bitmap>> {
         self.map.get(key)
     }

imageflow_core/src/json/endpoints/openapi_schema_v1.json.hash

@@ -1 +1 @@
-25c79175077e3250d368939492d2954c
+94d84502e2b43c3605ef1f55fb2e9d39