Decrease reallocs

Author: owjs3901

crates/vespera_inprocess/src/wire.rs

@@ -302,6 +302,31 @@ pub fn header_capacity_estimate(headers: &http::HeaderMap, metadata: &ResponseMe
     est
 }
 
+/// Cheap upper-ish estimate of the serialized `validation_errors` JSON
+/// array byte length, added to the response-`Vec` capacity **only on the
+/// 422 path** (`validation_errors` is `None` for every other status, so the
+/// hot success path pays nothing).  Each item renders as
+/// `{"path":"…","code":"…","message":"…"},` inside the
+/// `,"validation_errors":[…]` wrapper — count the field bytes plus a fixed
+/// per-item scaffold.  A safe over-estimate (absent `code`/`message` only
+/// shrink the real output), so it only ever prevents the mid-serialize
+/// realloc the hoisted errors would otherwise force; it never changes the
+/// emitted bytes.
+fn validation_errors_capacity_estimate(items: &[ValidationErrorItem]) -> usize {
+    // `,"validation_errors":[]` wrapper, plus per item the
+    // `{"path":"","code":"","message":""},` scaffold.
+    const WRAPPER: usize = 24;
+    const ITEM_SCAFFOLD: usize = 36;
+    let mut est = WRAPPER;
+    for item in items {
+        est += ITEM_SCAFFOLD
+            + item.path.len()
+            + item.code.as_deref().map_or(0, str::len)
+            + item.message.as_deref().map_or(0, str::len);
+    }
+    est
+}
+
 /// Append `[u32 BE header_len | header JSON]` to `out`.  Returns `false`
 /// when the serialized header JSON exceeds `u32::MAX` bytes — unreachable for
 /// any real `HeaderMap` (4 GiB of header JSON), so callers map it to a `500`
@@ -407,12 +432,19 @@ pub fn to_wire_bytes(parts: ResponseParts) -> Vec<u8> {
     } else {
         None
     };
-    let header_cap = header_capacity_estimate(&headers, &metadata).max(WIRE_HEADER_RESERVE);
+    let header_cap = header_capacity_estimate(&headers, &metadata).max(WIRE_HEADER_RESERVE)
+        + validation_errors
+            .as_deref()
+            .map_or(0, validation_errors_capacity_estimate);
     // `4 + header_cap + body_bytes.len()` cannot overflow `usize` on a
     // 64-bit target (it would require a multi-exabyte body); plain `+` is
     // used so the hot response path keeps its exact arithmetic — a
     // `saturating_add` variant was benchmarked and cost ~2-3% on the small
     // `wire_path`/`request_headers_path` cases for zero real-world benefit.
+    // The `validation_errors` term is `0` for every non-422 response (the hot
+    // success path is byte-for-byte unchanged); on the 422 path it sizes the
+    // `Vec` to serialise the hoisted errors without the mid-write realloc a
+    // hoist-blind estimate paid (locked by tests/alloc_budget.rs case F).
     let mut out = Vec::with_capacity(4 + header_cap + body_bytes.len());
     if !write_wire_header_into(
         &mut out,

crates/vespera_inprocess/tests/alloc_budget.rs

@@ -76,13 +76,33 @@ async fn echo(body: Bytes) -> Bytes {
     body
 }
 
+/// Returns a `422` with a JSON `{"errors":[...]}` body so the wire path
+/// exercises the `to_wire_bytes` 422 `validation_errors` hoist plus the
+/// header-capacity estimate. Two realistic errors push the hoisted header
+/// JSON past the `WIRE_HEADER_RESERVE` floor, so a build whose capacity
+/// estimate ignores the hoisted errors reallocates once mid-serialize; the
+/// validation-errors capacity estimate removes that realloc.
+async fn validate_fail() -> axum::response::Response {
+    use axum::response::IntoResponse;
+    (
+        axum::http::StatusCode::UNPROCESSABLE_ENTITY,
+        [(
+            axum::http::header::CONTENT_TYPE,
+            axum::http::HeaderValue::from_static("application/json"),
+        )],
+        r#"{"errors":[{"path":"username","message":"length is lower than 3"},{"path":"email","message":"not a valid email"}]}"#,
+    )
+        .into_response()
+}
+
 fn install() {
     static INIT: Once = Once::new();
     INIT.call_once(|| {
         register_app(|| {
             Router::new()
                 .route("/ping", get(ping))
                 .route("/echo", post(echo))
+                .route("/validate", post(validate_fail))
         });
     });
 }
@@ -209,6 +229,21 @@ fn allocation_budgets() {
         let _ = dispatch_into(wire_get.clone(), &mut out, &rt);
     });
 
+    // ── Case F: 422 JSON response via the buffered materialise path. The
+    // `to_wire_bytes` 422 path hoists `{"errors":[...]}` into the wire
+    // header's `validation_errors`. With the hoisted-errors length folded
+    // into the capacity estimate the response `Vec` is sized to serialise the
+    // header in one shot — the realloc a hoist-blind estimate paid is gone.
+    let wire_validate = encode(
+        "POST",
+        "/validate",
+        &[("content-type", "application/json")],
+        br#"{"x":1}"#,
+    );
+    let validate_422 = measure(200, 2000, || {
+        let _ = dispatch_from_bytes(wire_validate.clone(), &rt);
+    });
+
     // (label, sample, budget). The gate metric is total per-op allocation
     // OPS (`alloc` + `realloc` calls) — the deterministic, noise-free
     // figure; bytes/op is informational only.
@@ -234,6 +269,7 @@ fn allocation_budgets() {
             &direct_into,
             BUDGET_DISPATCH_INTO,
         ),
+        ("F 422-validate materialise", &validate_422, BUDGET_VALIDATE_422),
     ];
 
     // Print every case first so a regression failure still shows the full
@@ -282,3 +318,8 @@ const BUDGET_HEADERS_POST: usize = 40; // borrowed: 40 alloc + 0 realloc (header
 // path copy (or any other owned-path allocation) trips these tightened budgets.
 const BUDGET_MATERIALISE: usize = 16; // dispatch_from_bytes: +input clone +response Vec, URI shared
 const BUDGET_DISPATCH_INTO: usize = 15; // dispatch_into: +input clone, reused out, URI shared
+// 422 materialise path: the hoisted `validation_errors` JSON is now folded
+// into the response-`Vec` capacity estimate, so the wire header serialises
+// without the mid-write realloc a hoist-blind estimate paid (26 alloc + 0
+// realloc; was 26 alloc + 1 realloc). A re-introduced realloc trips this.
+const BUDGET_VALIDATE_422: usize = 26; // realloc-free 422 hoist (was 27 w/ realloc)

crates/vespera_macro/src/schema_macro/file_cache.rs

@@ -678,15 +678,19 @@ fn ensure_path_lookup_caches_fresh(cache: &mut FileCache) {
 /// The `Arc` makes cache hits O(1) instead of cloning the full struct
 /// definition text per lookup.
 ///
-/// The cache is scoped to the current epoch
-/// ([`ensure_path_lookup_caches_fresh`]): a new top-level macro invocation
-/// drops prior entries so an edited model file is re-resolved (correctness
-/// for long-lived rust-analyzer servers), while repeated lookups within the
-/// same invocation still hit the cache.
+/// The cache **survives epoch bumps** (see
+/// [`ensure_path_lookup_caches_fresh`]): entries key on a schema PATH string,
+/// and a cache MISS re-resolves through the lower file-content /
+/// struct-definition mtime caches — so within one `cargo build` (no source
+/// file changes mid-build) a surviving entry only ever returns the result a
+/// re-resolution would produce, while keeping repeated lookups O(1). A
+/// long-lived rust-analyzer proc-macro server therefore keeps a resolved
+/// entry until the server restarts — the documented cost of the shared-work
+/// optimisation (a future mtime-aware path cache could be warm AND fresh).
 pub fn get_struct_from_schema_path(path_str: &str) -> Option<Arc<StructMetadata>> {
-    // Drop stale (pre-edit) entries when the epoch advanced, then read this
-    // epoch's cache. The borrow ends before the lookup below, which
-    // re-enters FILE_CACHE.
+    // Re-stamp the path-lookup epoch (entries deliberately SURVIVE bumps — see
+    // `ensure_path_lookup_caches_fresh`), then read the cache. The borrow ends
+    // before the lookup below, which re-enters FILE_CACHE.
     let cached = FILE_CACHE.with(|cache| {
         let mut cache = cache.borrow_mut();
         ensure_path_lookup_caches_fresh(&mut cache);
@@ -716,9 +720,9 @@ pub fn get_struct_from_schema_path(path_str: &str) -> Option<Arc<StructMetadata>
 pub fn get_fk_column(schema_path: &str, via_rel: &str) -> Option<String> {
     let key = (schema_path.to_string(), via_rel.to_string());
 
-    // Drop stale entries when the epoch advanced, then read this epoch's
-    // cache. The borrow ends before the lookup below, which re-enters
-    // FILE_CACHE.
+    // Re-stamp the path-lookup epoch (entries deliberately SURVIVE bumps — see
+    // `ensure_path_lookup_caches_fresh`), then read this epoch's cache. The
+    // borrow ends before the lookup below, which re-enters FILE_CACHE.
     let cached = FILE_CACHE.with(|cache| {
         let mut cache = cache.borrow_mut();
         ensure_path_lookup_caches_fresh(&mut cache);