Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-core/tests/alloc_bounds.rs

Raw
//! Allocation-count bounds on session hot paths (`SMH-SPEC-SPEC0001`,
//! memory accounting). Bounds only tighten.

use smith::config::Config;
use smith::message::{Message, Role};
use smith::structured::StructuredData;
use smith_alloc::{Counting, Scope, measure};
use smith_core::content_codec::{Blocks, EntryContentView};
use smith_core::frame::Frame;
use smith_core::session::{EntryContent, EntryFrame, Session};
use smith_core::store::{SessionReader, SessionWriter, open_session};
use smith_core::trace::trace;
use std::sync::Mutex;

#[path = "support/child.rs"]
mod child_fixture;

#[global_allocator]
static ALLOC: Counting = Counting;

/// Scope counters are process-wide; measurements must not overlap.
static MEASURING: Mutex<()> = Mutex::new(());

/// `fork_at` over 1000 entries: the branch list, the record `Vec`, and one
/// arena slice. Content bytes are copied, never decoded.
const FORK_AT_1000_ALLOCATIONS: u64 = 3;

/// Encoding a header frame: one buffer sized by the payload hint holds the
/// prefix and the whole payload.
const HEADER_ENCODE_ALLOCATIONS: u64 = 1;

/// Streaming trace over two metadata records: one unrelated and one mutation completion.
const TRACE_REPLAY_METADATA_ALLOCATIONS: u64 = 90;

#[test]
fn streaming_redaction_allocation_count_is_pinned() {
    use futures::StreamExt;
    use smith::stream::{StopReason, StreamEvent};
    use smith_core::agent::Agent;
    use smith_core::tools::ToolSession;
    let stream: smith::provider::StreamFn = std::sync::Arc::new(|_, _| {
        futures::stream::iter(vec![
            Ok(StreamEvent::text_delta(
                smith::id::MessageId::new(),
                "public prefix ab",
            )),
            Ok(StreamEvent::text_delta(
                smith::id::MessageId::new(),
                "ordinary text",
            )),
            Ok(StreamEvent::stop(StopReason::EndTurn, None)),
        ])
        .boxed()
    });
    let mut agent = Agent::new(stream, ToolSession::new(std::env::temp_dir()), "mock");
    agent.secrets_mut().register("synthetic", "abcdef");
    let ((allocations, _), outcome) = session_cost(|| agent.run_turn("input").unwrap());
    assert_eq!(outcome.text, "public prefix abordinary text");
    // Redactor's no-secret fast path removes one temporary allocation.
    assert_eq!(allocations, 51);
}

#[test]
fn cancellation_intent_encodes_in_one_fixed_buffer() {
    let frame = Frame::CancelIntent {
        submission_id: smith::id::EntryId::new(),
    };
    let ((allocations, _), bytes) = session_cost(|| frame.encode(1024).unwrap());
    assert_eq!(allocations, 1);
    assert_eq!(bytes.len(), 37);
}

#[test]
fn admission_encoding_has_two_bounded_allocations() {
    let entry = EntryFrame::new(
        None,
        &EntryContent::Message(Message::with_text(Role::User, "hello")),
    )
    .unwrap();
    let frame = Frame::Admission {
        entry,
        key: Some("k".repeat(smith_core::frame::ADMISSION_KEY_BYTES_MAX)),
    };
    let ((allocations, _), bytes) = session_cost(|| frame.encode(1024).unwrap());
    assert_eq!(allocations, 2);
    assert!(
        bytes.len() <= 1024 + smith_core::frame::HEADER_LEN + smith_core::frame::BODY_PREFIX_LEN
    );
}

#[test]
fn work_commit_encoding_uses_one_bounded_buffer() {
    let submission_id = smith::id::EntryId::new();
    let output = EntryFrame::new(
        Some(submission_id),
        &EntryContent::Message(Message::with_text(Role::Assistant, "answer")),
    )
    .unwrap();
    for frame in [
        Frame::Claim { submission_id },
        Frame::Settlement {
            submission_id,
            reason: Some(smith::stream::StopReason::EndTurn),
            output: Some(output),
        },
    ] {
        let ((allocations, _), bytes) = session_cost(|| frame.encode(1024).unwrap());
        assert_eq!(allocations, 1);
        assert!(
            bytes.len()
                <= 1024 + smith_core::frame::HEADER_LEN + smith_core::frame::BODY_PREFIX_LEN
        );
    }
    assert_eq!(std::mem::size_of::<smith_core::store::WorkStatus>(), 1);
    assert_eq!(
        std::mem::size_of::<(smith::id::EntryId, smith_core::store::WorkStatus)>(),
        17
    );
}

/// `from_frames` over 1000 decoded frames: arena, stored records, the
/// parent-link table, the branch list, and one branch's records, each sized
/// up front. Independent of entry count.
const FROM_FRAMES_1000_ALLOCATIONS: u64 = 5;

fn linear_session(len: usize) -> Session {
    let mut session = Session::new();
    for turn in 0..len {
        let content = EntryContent::Message(Message::with_text(Role::User, format!("turn {turn}")));
        session.append(&content).unwrap();
    }
    session
}

/// Allocations and bytes charged to [`Scope::Session`] while `run` executes.
fn session_cost<T>(run: impl FnOnce() -> T) -> ((u64, u64), T) {
    let _serial = MEASURING
        .lock()
        .unwrap_or_else(std::sync::PoisonError::into_inner);
    let (out, cost) = measure(Scope::Session, run);
    ((cost.allocations, cost.bytes), out)
}

/// Cost of one `fork_at` of the leaf.
fn fork_cost(session: &Session) -> (u64, u64) {
    let leaf = session.selected_id().expect("non-empty session");
    let (cost, fork) = session_cost(|| session.fork_at(leaf).expect("leaf is known"));
    assert_eq!(
        fork.active_branch().entries().len(),
        session.active_branch().entries().len()
    );
    let last = fork.active_branch().entries()[fork.active_branch().entries().len() - 1];
    assert_eq!(fork.bytes(&last), session.bytes(&last));
    cost
}

/// Cost of restoring `session` from its decoded frames; frame decoding
/// itself happens before the measured scope.
fn from_frames_cost(session: &Session) -> (u64, u64) {
    let mut frames = vec![Frame::Header {
        header: session.header(),
    }];
    frames.extend(
        session
            .active_branch()
            .entries()
            .iter()
            .map(|entry| Frame::Known {
                entry: EntryFrame {
                    id: entry.id,
                    parent: entry.parent,
                    timestamp_ms: entry.timestamp_ms,
                    kind: entry.kind,
                    content: session.bytes(entry).to_vec(),
                },
            }),
    );
    let (cost, restored) = session_cost(|| Session::from_frames(&frames).expect("frames restore"));
    assert_eq!(&restored, session);
    cost
}

#[test]
fn selected_context_allocation_is_independent_of_old_and_unrelated_payloads() {
    fn cost(old_bytes: usize, tag: &str) -> (u64, u64) {
        let path =
            std::env::temp_dir().join(format!("smith-effective-{tag}-{}.smh", std::process::id()));
        let _ = std::fs::remove_file(&path);
        let cfg = Config::default_valid();
        let mut opened = open_session(&path, cfg.clone()).unwrap();
        let old = EntryFrame::new(
            None,
            &EntryContent::Message(Message::with_text(Role::User, "x".repeat(old_bytes))),
        )
        .unwrap();
        let compact = EntryFrame::new(
            Some(old.id),
            &EntryContent::Meta {
                kind: smith_core::session::COMPACTION_KIND.into(),
                detail: StructuredData::from_serializable(&serde_json::json!({"summary": ""}))
                    .unwrap(),
            },
        )
        .unwrap();
        let after = EntryFrame::new(
            Some(compact.id),
            &EntryContent::Message(Message::with_text(Role::User, "after")),
        )
        .unwrap();
        let unrelated = EntryFrame::new(
            Some(old.id),
            &EntryContent::Message(Message::with_text(Role::User, "y".repeat(old_bytes))),
        )
        .unwrap();
        for entry in [&old, &compact, &after, &unrelated] {
            opened
                .writer
                .append_frame(&Frame::Known {
                    entry: entry.clone(),
                })
                .unwrap();
        }
        opened.writer.select_entry(after.id).unwrap();
        drop(opened);
        let reader = SessionReader::open(&path).unwrap();
        let (selected, cost) = measure(Scope::Session, || {
            reader.selected_session(cfg.frame_bytes_max).unwrap()
        });
        assert_eq!(selected.active_branch().entries().len(), 2);
        drop(reader);
        let _ = std::fs::remove_file(path);
        (cost.allocations, cost.bytes)
    }
    let _lock = MEASURING.lock().unwrap();
    let small = cost(100, "small");
    let large = cost(400_000, "large");
    assert_eq!(
        small, large,
        "pre-compaction and sibling payloads must not be retained or decoded"
    );
}

#[test]
fn fork_at_over_1000_entries_is_bounded_and_reproducible() {
    let session = linear_session(1000);
    let first = fork_cost(&session);
    let second = fork_cost(&session);
    assert_eq!(
        first.0, FORK_AT_1000_ALLOCATIONS,
        "fork_at allocated {} times, bound is {FORK_AT_1000_ALLOCATIONS}",
        first.0
    );
    assert_eq!(first, second);
}

#[test]
fn from_frames_allocates_independently_of_entry_count() {
    let small = from_frames_cost(&linear_session(100));
    let large = from_frames_cost(&linear_session(1000));
    assert_eq!(
        large.0, FROM_FRAMES_1000_ALLOCATIONS,
        "from_frames allocated {} times, bound is {FROM_FRAMES_1000_ALLOCATIONS}",
        large.0
    );
    assert_eq!(small.0, large.0);
    assert_eq!(large, from_frames_cost(&linear_session(1000)));
}

#[cfg(target_arch = "x86_64")]
#[test]
fn trace_replay_metadata_allocations_are_pinned() {
    // scratch_file constructs paths from TMPDIR during the measured replay.
    // A fixed relative spelling keeps PathBuf growth independent of OS root
    // length; a child avoids process-wide environment mutation and count noise.
    const CHILD: &str = "SMITH_TRACE_ALLOCATION_CHILD";
    if std::env::var_os(CHILD).is_none() {
        let root = std::env::temp_dir().join(format!("trace-pins-{}", std::process::id()));
        std::fs::create_dir(&root).unwrap();
        let output = child_fixture::run(
            std::process::Command::new(std::env::current_exe().unwrap())
                .args(["--exact", "trace_replay_metadata_allocations_are_pinned"])
                .current_dir(&root)
                .env("TMPDIR", ".")
                .env(CHILD, "1"),
        );
        std::fs::remove_dir_all(root).unwrap();
        assert!(
            output.status.success(),
            "trace allocation child failed: {}{}",
            String::from_utf8_lossy(&output.stdout),
            String::from_utf8_lossy(&output.stderr)
        );
        return;
    }
    let _serial = MEASURING.lock().unwrap();
    let path = std::env::temp_dir().join(format!("smith-trace-alloc-{}.smh", std::process::id()));
    let _ = std::fs::remove_file(&path);
    let config = Config::default_valid();
    let mut opened = open_session(&path, config.clone()).unwrap();
    let call_id = smith::ToolCallId::from_u128(1);
    let call = EntryFrame::new(
        None,
        &EntryContent::ToolCall {
            name: "write".to_string(),
            input: smith::ToolArguments::from_serializable(
                &serde_json::json!({"path": "note.txt", "content": "x"}),
            )
            .unwrap(),
            call_id,
        },
    )
    .unwrap();
    let result = EntryFrame::new(
        Some(call.id),
        &EntryContent::ToolResult {
            ok: true,
            output: "written".to_string(),
            call_id,
        },
    )
    .unwrap();
    let unrelated = EntryFrame::new(
        Some(result.id),
        &EntryContent::Meta {
            kind: "custom".to_string(),
            detail: StructuredData::from_serializable(
                &serde_json::json!({"payload": "x".repeat(4096)}),
            )
            .unwrap(),
        },
    )
    .unwrap();
    let completion = EntryFrame::new(
        Some(unrelated.id),
        &EntryContent::Meta {
            kind: smith_core::session::TOOL_MUTATION_KIND.to_string(),
            detail: StructuredData::from_serializable(
                &serde_json::json!({"call_id": call_id, "mutation_state": "applied"}),
            )
            .unwrap(),
        },
    )
    .unwrap();
    for entry in [&call, &result, &unrelated, &completion] {
        opened
            .writer
            .append_frame(&Frame::Known {
                entry: entry.clone(),
            })
            .unwrap();
    }
    drop(opened);

    let reader = SessionReader::open(&path).unwrap();
    let (records, cost) = measure(Scope::Session, || {
        let mut records = 0usize;
        trace(&reader, config.frame_bytes_max, |_| {
            records += 1;
            Ok(())
        })
        .unwrap();
        records
    });
    assert_eq!(records, 5);
    assert_eq!(
        cost.allocations, TRACE_REPLAY_METADATA_ALLOCATIONS,
        "trace allocations: {cost:?}"
    );
    drop(reader);
    std::fs::remove_file(path).unwrap();
}

#[cfg(target_arch = "x86_64")]
#[test]
fn decoded_content_view_fits_one_cache_line_and_blocks_three_words() {
    assert_eq!(std::mem::size_of::<EntryContentView<'_>>(), 56);
    assert_eq!(std::mem::size_of::<Blocks<'_>>(), 24);
}

#[test]
fn text_only_content_decode_and_scan_allocate_nothing() {
    let content = EntryFrame::new(
        None,
        &EntryContent::Message(Message::with_text(Role::User, "needle")),
    )
    .unwrap()
    .content;
    let (cost, found) = session_cost(|| {
        let view = EntryContentView::decode(&content).unwrap();
        view.contains("needle")
    });
    assert!(found);
    assert_eq!(cost.0, 0, "text inspection allocated {} times", cost.0);
}

#[test]
fn nested_json_inspection_borrows_without_allocating() {
    let content = EntryFrame::new(
        None,
        &EntryContent::Meta {
            kind: "event".into(),
            detail: StructuredData::from_serializable(
                &serde_json::json!({"outer": [{"value": "needle"}, 0, false, null]}),
            )
            .unwrap(),
        },
    )
    .unwrap()
    .content;
    let (cost, found) = session_cost(|| {
        let view = EntryContentView::decode(&content).unwrap();
        view.contains("needle")
    });
    assert!(found);
    assert_eq!(cost.0, 0, "JSON inspection allocated {} times", cost.0);
}

#[test]
fn unrelated_history_does_not_become_resident_selected_context() {
    // SMH-SPEC-SPEC0001: Sessions, context memory ≠ complete file size.
    let path = std::env::temp_dir().join(format!("smith-paged-memory-{}.smh", std::process::id()));
    let _ = std::fs::remove_file(&path);
    let cfg = Config::default_valid();
    let mut writer = SessionWriter::open(&path, cfg.clone()).unwrap();
    writer
        .append_frame(&Frame::Header {
            header: Session::new().header(),
        })
        .unwrap();
    let root = EntryFrame::new(
        None,
        &EntryContent::Message(Message::with_text(Role::User, "root")),
    )
    .unwrap();
    writer
        .append_frame(&Frame::Known {
            entry: root.clone(),
        })
        .unwrap();
    for _ in 0..128 {
        let sibling = EntryFrame::new(
            Some(root.id),
            &EntryContent::Message(Message::with_text(Role::User, "x".repeat(32 * 1024))),
        )
        .unwrap();
        writer
            .append_frame(&Frame::Known { entry: sibling })
            .unwrap();
    }
    writer.select_entry(root.id).unwrap();
    let reader = SessionReader::open(&path).unwrap();
    let _serial = MEASURING
        .lock()
        .unwrap_or_else(std::sync::PoisonError::into_inner);
    let (selected, cost) = measure(Scope::IoRequest, || {
        reader.selected_session(cfg.frame_bytes_max).unwrap()
    });
    assert_eq!(selected.selected_id(), Some(root.id));
    assert_eq!(selected.active_branch().entries().len(), 1);
    assert!(
        cost.peak < 256 * 1024,
        "selected context peak {} bytes for {}-byte file",
        cost.peak,
        reader.file_size()
    );
    assert!(reader.file_size() > 4 * 1024 * 1024);
    drop(reader);
    drop(writer);
    let _ = std::fs::remove_file(path);
}

#[test]
fn header_frame_encodes_into_one_allocation() {
    let header = Frame::Header {
        header: Session::new().header(),
    };
    let (cost, encoded) =
        session_cost(|| header.encode(smith_core::frame::DEFAULT_MAX_FRAME_BYTES));
    assert!(encoded.is_ok());
    assert_eq!(
        cost.0, HEADER_ENCODE_ALLOCATIONS,
        "header encode allocated {} times, bound is {HEADER_ENCODE_ALLOCATIONS}",
        cost.0
    );
}

#[test]
fn borrowed_context_edit_decode_allocates_nothing() {
    use smith_core::context::{ContextEdit, ContextReplacement};
    let content = EntryContent::ContextEdit(vec![
        ContextEdit {
            target: smith::id::EntryId::from_u128(1),
            replacement: Some(ContextReplacement::Text("replacement".into())),
        },
        ContextEdit {
            target: smith::id::EntryId::from_u128(2),
            replacement: Some(ContextReplacement::AssistantText("prose".into())),
        },
        ContextEdit {
            target: smith::id::EntryId::from_u128(3),
            replacement: Some(ContextReplacement::ToolResultOutput {
                call_id: smith::id::ToolCallId::from_u128(4),
                output: "output".into(),
            }),
        },
    ]);
    let entry = EntryFrame::new(None, &content).unwrap();
    let (cost, decoded) = session_cost(|| EntryContentView::decode(&entry.content).unwrap());
    assert_eq!(cost, (0, 0));
    assert!(matches!(decoded, EntryContentView::ContextEdit(_)));
}

#[test]
fn context_validation_borrows_large_unedited_payloads() {
    use smith_core::context::{ContextEdit, ContextReplacement};
    let mut session = Session::new();
    session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "x".repeat(1 << 20),
        )))
        .unwrap();
    let target = session
        .append(&EntryContent::Message(Message::with_text(
            Role::User,
            "target",
        )))
        .unwrap()
        .id;
    let edit = ContextEdit {
        target,
        replacement: Some(ContextReplacement::AssistantText("wrong role".into())),
    };
    // The only allocation is the rejection diagnostic, not any resident message.
    let (cost, rejected) = session_cost(|| {
        session.edit_context_with(&[edit], |_, _| panic!("invalid edit reached persistence"))
    });
    assert!(rejected.is_err());
    assert_eq!(cost.0, 1);
}

#[test]
fn repeated_replacements_retain_effective_context_not_edit_history() {
    use smith_alloc::snapshot;
    use smith_core::context::{ContextEdit, ContextReplacement};
    let config = Config::default_valid();
    let original = EntryContent::Message(Message::with_text(Role::User, "raw".repeat(170_000)));
    let large = "replacement".repeat(5_000);
    let _serial = MEASURING
        .lock()
        .unwrap_or_else(std::sync::PoisonError::into_inner);
    let mut restored_residency = None;
    let mut live_residency = None;
    let mut claimed_residency = None;
    for count in [10, 100] {
        let path = std::env::temp_dir().join(format!(
            "smith-edit-working-set-{}-{count}.smh",
            smith::id::SessionId::new()
        ));
        let mut writer = SessionWriter::open(&path, config.clone()).unwrap();
        writer
            .append_frame(&Frame::Header {
                header: Session::new().header(),
            })
            .unwrap();
        let root = EntryFrame::new(None, &original).unwrap();
        writer
            .append_frame(&Frame::Known {
                entry: root.clone(),
            })
            .unwrap();
        let mut parent = root.id;
        for index in 0..=count {
            let entry = EntryFrame::new(
                Some(parent),
                &EntryContent::ContextEdit(vec![ContextEdit {
                    target: root.id,
                    replacement: Some(ContextReplacement::Text(if index == count {
                        "tiny".into()
                    } else {
                        large.clone()
                    })),
                }]),
            )
            .unwrap();
            parent = entry.id;
            writer.append_frame(&Frame::Known { entry }).unwrap();
        }
        let reader = SessionReader::open(&path).unwrap();
        let before = snapshot(Scope::IoRequest).live;
        let ((mut selected, effective), cost) = measure(Scope::IoRequest, || {
            let selected = reader.selected_session(config.frame_bytes_max).unwrap();
            let effective = selected.projected_messages().unwrap();
            (selected, effective)
        });
        let resident = snapshot(Scope::IoRequest).live.saturating_sub(before);
        if let Some(first) = restored_residency {
            assert_eq!(
                resident, first,
                "history growth must not increase residency"
            );
        }
        restored_residency = Some(resident);
        assert_eq!(
            effective[0].blocks,
            Message::with_text(Role::User, "tiny").blocks
        );
        assert!(
            resident <= 1536,
            "{count} replacements retain {resident} bytes; peak {}",
            cost.peak
        );
        assert!(
            cost.peak <= 1536 * 1024,
            "{count} replacements peak {}",
            cost.peak
        );
        assert_eq!(selected.selected_id(), Some(parent));
        assert_eq!(selected.active_branch().entries().len(), 2);
        assert_eq!(
            selected.projected_messages().unwrap()[0].blocks,
            Message::with_text(Role::User, "tiny").blocks
        );
        let raw = selected
            .active_branch()
            .entries()
            .iter()
            .find(|entry| entry.id == root.id)
            .unwrap();
        assert_eq!(selected.content(raw).unwrap(), original);
        let mut raw_count = 0;
        reader
            .replay_at(parent, config.frame_bytes_max, |_| {
                raw_count += 1;
                Ok(())
            })
            .unwrap();
        assert_eq!(raw_count, count + 2);
        println!(
            "restore count={count}: resident={resident}, peak={}",
            cost.peak
        );
        // Reuse caller-owned edits: only implementation working memory is measured.
        let large_edit = [ContextEdit {
            target: root.id,
            replacement: Some(ContextReplacement::Text(large.clone())),
        }];
        let tiny_edit = [ContextEdit {
            target: root.id,
            replacement: Some(ContextReplacement::Text("tiny".into())),
        }];
        let (live_effective, live_cost) = measure(Scope::IoRequest, || {
            for _ in 0..count {
                selected
                    .edit_context_with(&large_edit, |entry, bytes| {
                        writer.append_entry(entry, bytes)
                    })
                    .unwrap();
            }
            selected
                .edit_context_with(&tiny_edit, |entry, bytes| writer.append_entry(entry, bytes))
                .unwrap();
            selected.projected_messages().unwrap()
        });
        assert_eq!(live_effective, effective);
        let live_resident = snapshot(Scope::IoRequest).live.saturating_sub(before);
        if let Some(first) = live_residency {
            assert_eq!(
                live_resident, first,
                "live history growth must not increase residency"
            );
        }
        live_residency = Some(live_resident);
        println!(
            "live count={count}: resident={live_resident}, peak={}",
            live_cost.peak
        );
        assert!(
            live_resident <= 1536,
            "{count} live replacements retain {live_resident}"
        );
        assert!(
            live_cost.peak <= 1536 * 1024,
            "{count} live replacements peak {}",
            live_cost.peak
        );
        assert_eq!(
            selected.projected_messages().unwrap()[0].blocks,
            Message::with_text(Role::User, "tiny").blocks
        );
        assert_eq!(selected.active_branch().entries().len(), 2);
        let queued = Message::with_text(Role::User, "queued");
        let receipt = writer.admit(&queued, None, None).unwrap();
        let before_claim = snapshot(Scope::IoRequest).live;
        let ((claimed, request), claim_cost) = measure(Scope::IoRequest, || {
            let claimed = writer.claim(receipt.submission_id).unwrap();
            let request = claimed.projected_messages().unwrap();
            (claimed, request)
        });
        let claim_resident = snapshot(Scope::IoRequest).live.saturating_sub(before_claim);
        println!(
            "claim count={count}: resident={claim_resident}, peak={}",
            claim_cost.peak
        );
        if let Some(first) = claimed_residency {
            assert_eq!(claim_resident, first);
        }
        claimed_residency = Some(claim_resident);
        assert!(claim_resident <= 1536, "claim retains {claim_resident}");
        assert!(
            claim_cost.peak <= 1536 * 1024,
            "claim peak {}",
            claim_cost.peak
        );
        assert_eq!(request.len(), 2);
        assert_eq!(request[0], effective[0]);
        assert_eq!(request[1], queued);
        drop(claimed);
        drop(request);
        drop(selected);
        drop(reader);
        drop(writer);
        std::fs::remove_file(path).unwrap();
    }
}